TypeScript avancé

export function instrumentUseCase<T extends object>(name: string, instance: T): T {
  return new Proxy(instance, {
    get(target, prop) {
      const value = (target as Record<PropertyKey, unknown>)[prop]
      if (prop !== 'execute' || typeof value !== 'function') {
        return typeof value === 'function' ? value.bind(target) : value
      }
      // …
    },
  })
}

export function instrumentContainer<C extends Record<string, unknown>>(
  container: C,
  exclude: ReadonlySet<string>,
): C {
  const isUseCase = (value: unknown): value is object =>
    typeof value === 'object' &&
    value !== null &&
    typeof (value as { execute?: unknown }).execute === 'function'
  return Object.fromEntries(
    Object.entries(container).map(([key, value]) =>
      exclude.has(key) || !isUseCase(value)
        ? [key, value]
        : [key, instrumentUseCase(value.constructor.name, value)],
    ),
  ) as C
}

/** Runs `work` inside a Mongo multi-document transaction. */
async runInTransaction<T>(
  work: (session: ClientSession) => Promise<T>,
): Promise<T> {
  const session = await this.connection.startSession();
  try {
    let result: T;
    await session.withTransaction(async () => {
      result = await work(session);
    });
    return result!;
  } finally {
    await session.endSession();
  }
}

export interface PhoneValue<C extends PhoneCountry = CountryConfig> {
  dialCode: string
  localNumber: string
  full: string
  country: C
}

export type InternationalPhoneValue = PhoneValue<PhoneCountry>

interface PhoneInputProps<C extends PhoneCountry> {
  value: PhoneValue<C>
  onChange: (value: PhoneValue<C>) => void
  /**
   * The conditional type LOCKS the scope to the country type carried by the
   * value: a state typed CountryConfig (currency, operators) only accepts
   * scope="payment"; a bare InternationalPhoneValue only accepts
   * scope="international".
   */
  scope?: C extends CountryConfig ? 'payment' : 'international'
  countries?: readonly C[]
}

/**
 * Convertit les Date en string — reflète la sérialisation JSON de l'API.
 * Utilisé pour typer les réponses API dans les hooks SWR.
 */
export type Serialized<T> = {
  [K in keyof T]: T[K] extends Date
    ? string
    : T[K] extends Date | undefined
      ? string | undefined
      : T[K] extends object
        ? Serialized<T[K]>
        : T[K]
}

/** Valeur portée par le Result en cas de succès de execute(). */
export type UseCaseOutput<U> = U extends {
  execute(...args: never[]): Promise<Result<infer V, unknown>>
}
  ? V
  : never

// src/presentation/hooks/useHomeFeed.ts
type HomeFeedResponse = UseCaseOutput<GetHomeFeedUseCase>

export function useHomeFeed() {
  const { data, error, isLoading } = useSWR<HomeFeedResponse>('/api/feed', fetcher, {
    // …
  })
  return { items: data?.items ?? [], loading: isLoading, error: error?.message ?? null }
}

/** Valeur du select « Événement / compétition / artiste » : `event:<id>` … ou ''. */
export type ScopeValue = '' | `event:${string}` | `competition:${string}` | `artist:${string}`

export function scopeValueOf(f: Pick<PaymentCaseFilters, 'eventId' | 'competitionId' | 'artistId'>): ScopeValue {
  if (f.eventId) return `event:${f.eventId}`
  if (f.competitionId) return `competition:${f.competitionId}`
  if (f.artistId) return `artist:${f.artistId}`
  return ''
}

export type PollPlan =
  | { mode: 'nokash'; url: string }
  | { mode: 'status-url'; url: string }
  | { mode: 'blind' }

export type PollOutcome =
  | { kind: 'pending' }
  | { kind: 'success' }
  | { kind: 'failed'; message: string }

export function interpretPollStatus(status: string | undefined, t: PollT): PollOutcome {
  switch (status) {
    case 'SUCCESS':
    case 'CONFIRMED':
    case 'FREE':
      return { kind: 'success' }
    case 'CANCELED':
      return { kind: 'failed', message: t('canceled') }
    // …
  }
}

// src/core/domain/shared/assertNever.ts
export function assertNever(value: never, message?: string): never {
  throw new Error(message ?? `Variante non prise en charge : ${describe(value)}`)
}

// src/presentation/views/public/MobileHomeFeedView.tsx
function feedItemKey(item: FeedItem): string {
  switch (item.kind) {
    case 'competition':
      return `c:${item.competition.id}`
    // …
    case 'release':
      return `m:${item.release.id}`
    default:
      return assertNever(item)
  }
}

export type QuestionTopic =
  | "household"
  | "spouse"
  | "age"
  // … 14 autres sujets
  | "ties";

function topicAnswered(ctx: ScoringContext, topic: QuestionTopic): boolean {
  const a = ctx.answers;
  const set = (v: unknown) => v !== undefined && v !== null;
  switch (topic) {
    case "household":
      return true;
    case "spouse":
      return set(a.spouseEducation) || set(a.spouseLanguageLevel);
    // … un cas par membre de l'union, aucun default
    case "ties":
      return set(a.tiesToHome);
  }
}

export const SUPPORTED_LANGUAGES = ["fr", "en", "de", "it", "nl"] as const;
export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];

export function isSupportedLanguage(
  lang: LanguageCode,
): lang is SupportedLanguage {
  return (SUPPORTED_LANGUAGES as readonly string[]).includes(lang);
}

/** Niveaux de langue déclarés, indexés par code ISO. */
const LEVEL_FIELDS: Record<SupportedLanguage, keyof WizardState> = {
  fr: "fr",
  en: "en",
  de: "de",
  it: "it",
  nl: "nl",
};

export function requireAuth(session: Session | null): asserts session is Session {
  if (!session?.user) {
    throw new AuthenticationError()
  }
}

export function requireRole(
  session: Session | null,
  ...roles: UserRole[]
): asserts session is Session {
  requireAuth(session)

  if (!roles.includes(session?.user?.role as UserRole)) {
    throw new ForbiddenError(
      `Rôle requis : ${roles.join(' ou ')}. Vous avez : ${session?.user?.role}`,
    )
  }
}

export function requireAdmin(session: Session | null): asserts session is Session {
  requireRole(session, 'ADMIN')
}

declare const MsisdnBrand: unique symbol

export type Msisdn = string & { readonly [MsisdnBrand]: true }

export function isMsisdn(value: unknown): value is Msisdn {
  return typeof value === 'string' && CANONICAL_RE.test(value)
}

// src/infrastructure/payment/routing/cameroonOperator.ts
export interface CameroonMsisdn {
  msisdn: Msisdn
  operator: MobileMoneyOperator
}

export function cameroonMsisdn(phone: string | null | undefined): CameroonMsisdn | null {
  // … normalise l'entrée et détecte l'opérateur …
  const msisdn = `237${national}`
  if (!isMsisdn(msisdn)) return null
  return { msisdn, operator }
}

const COPY = {
  fr: {
    title: 'L’application a rencontré un problème',
    body: 'Ce n’est pas de votre fait : l’incident nous a été signalé. Rechargez la page — la plupart du temps, tout rentre dans l’ordre.',
    reload: 'Recharger',
    home: 'Retour à l’accueil',
  },
  en: {
    title: 'Something went wrong',
    body: 'This is not your fault — the incident has been reported. Reload the page: most of the time, everything comes back.',
    reload: 'Reload',
    home: 'Back to home',
  },
} satisfies Record<AppLocale, Record<string, string>>

/** Valeur initiale vide pour la portée demandée. */
export function emptyPhoneValue(): PhoneValue<CountryConfig>
export function emptyPhoneValue(scope: 'payment'): PhoneValue<CountryConfig>
export function emptyPhoneValue(scope: 'international'): InternationalPhoneValue
export function emptyPhoneValue(scope: PhoneScope = 'payment'): PhoneValue<PhoneCountry> {
  const country: PhoneCountry =
    scope === 'payment'
      ? DEFAULT_COUNTRY
      : (ALL_COUNTRIES.find((c) => c.iso2 === DEFAULT_COUNTRY.iso2) ?? ALL_COUNTRIES[0])
  return {
    dialCode: country.dialCode,
    localNumber: '',
    full: country.dialCode,
    country,
  }
}

import type { Messages as AppMessages } from './loadMessages'

declare global {
  interface IntlMessages extends AppMessages {}
}

export {}

// loadMessages.ts
export function loadMessages(locale: AppLocale) {
  return catalogs[locale]
}

export type Messages = (typeof catalogs)['fr']

import type { useTranslations } from 'next-intl'

/** Traducteur de l'espace `hooks.paymentPolling`. */
export type PollT = ReturnType<typeof useTranslations<'hooks.paymentPolling'>>

export function interpretPollStatus(status: string | undefined, t: PollT): PollOutcome {
  // …
}

const REQUIRED_ALWAYS = ['MONGODB_URI'] as const

const REQUIRED_IN_PRODUCTION = [
  'JWT_ACCESS_SECRET',
  'PAYMENT_WEBHOOK_BASE_URL',
] as const

export function validateEnv(raw: Record<string, unknown>): Record<string, unknown> {
  const isProduction = raw.NODE_ENV === 'production'
  const errors: string[] = []
  const value = (key: string): string => String(raw[key] ?? '').trim()

  const required = [
    ...REQUIRED_ALWAYS,
    ...(isProduction ? REQUIRED_IN_PRODUCTION : []),
  ]
  for (const key of required) {
    if (!value(key)) errors.push(`${key} is required`)
  }
  // …
  return raw
}

// DomainId.ts
export abstract class DomainId {
  protected constructor(readonly value: string) {
    if (!value || value.trim().length === 0) {
      throw new Error(`${this.constructor.name} cannot be empty`)
    }
  }

  equals(other: DomainId): boolean {
    return this.value === other.value
  }
}

// Entity.ts
export abstract class Entity<TId extends DomainId> {
  protected constructor(readonly id: TId) {}

  equals(other: Entity<TId>): boolean {
    return this.id.equals(other.id)
  }
}