---
title: "@xid-kit/angular"
description: "Fournisseur standalone Angular 17+, service RxJS, guards de routefonctionnels et composants standalone construits sur @xid-kit/core."
locale: "fr"
---

> Documentation Index
> Fetch the locale documentation index at: https://xid.dev/fr/llms.txt
> Use this file to discover all available pages before exploring further.

# @xid-kit/angular

## Statut

Le statut du package est **Package actuel**. Le fournisseur standaloneAngular 17+, le service RxJS, les guards fonctionnels et les composantsstandalone sont implémentés. Un aller-retour réel avec un IdP sur uneinfrastructure de production est en attente de vérification manuelle.

## Configuration du fournisseur

Appelez `provideXid` dans `app.config.ts`. Cela enregistre letoken d'injection `XID_CLIENT` et câble un `APP_INITIALIZER` quiappelle `client.load()` au démarrage. Aucun NgModule requis.

```ts
// app.config.ts
import { ApplicationConfig } from '@angular/core'
import { provideXid } from '@xid-kit/angular'

export const appConfig: ApplicationConfig = {
  providers: [
provideXid({ apiUrl: 'https://app.xid.dev' }),
  ],
}
```

## XidAuthService

```ts
import { Component, inject } from '@angular/core'
import { AsyncPipe } from '@angular/common'
import { XidAuthService } from '@xid-kit/angular'

@Component({
  selector: 'app-header',
  standalone: true,
  imports: [AsyncPipe],
  template: `
@if (auth.isLoaded$ | async) {
  @if (auth.isSignedIn$ | async) {
    <span>{{ (auth.user$ | async)?.primaryEmailAddress }}</span>
  } @else {
    <a routerLink="/sign-in">Sign in</a>
  }
}
  `,
})
export class HeaderComponent {
  readonly auth = inject(XidAuthService)
}
```

## Pont de signaux Angular

Utilisez `toSignal()` depuis `@angular/core/rxjs-interop` pourconvertir des observables en signaux pour les lectures de templates.

```ts
import { toSignal } from '@angular/core/rxjs-interop'
import { inject } from '@angular/core'
import { XidAuthService } from '@xid-kit/angular'

@Component({ standalone: true, ... })
export class MyComponent {
  readonly #auth = inject(XidAuthService)
  readonly user = toSignal(this.#auth.user$, { initialValue: null })
}
```

## Guards de route

```ts
import { Routes } from '@angular/router'
import { authGuard, hasOrganizationGuard, hasPermissionGuard } from '@xid-kit/angular'

export const routes: Routes = [
  {
path: 'dashboard',
canActivate: [authGuard()],
loadComponent: () => import('./dashboard.component').then(m => m.DashboardComponent),
  },
  {
path: 'admin',
canActivate: [hasPermissionGuard('org:settings:write')],
loadComponent: () => import('./admin.component').then(m => m.AdminComponent),
  },
]
```

## Composants standalone

```html
<!-- template -->
<xid-sign-in-button signInUrl="/sign-in" redirectUrl="/dashboard">Log in</xid-sign-in-button>
<xid-sign-out-button redirectUrl="/home">Log out</xid-sign-out-button>
```

## API exportée

| Exporter | Type | Objectif |
| --- | --- | --- |
| `provideXid` | function | Enregistre le singleton XID\_CLIENT et APP\_INITIALIZER ; accepteProvideXidOptions |
| `XID_CLIENT` | InjectionToken | L'instance brute de XidClient ; préférez XidAuthService pour la plupartdes cas d'usage |
| `XidAuthService` | service | Observables RxJS : state$, isLoaded$, isSignedIn$, user$, session$,organization$ ; plus getToken, signOut, setActiveOrganization,setActiveSession |
| `authGuard` | Fabrique CanActivateFn | Redirige vers /sign-in quand l'utilisateur n'est pas connecté |
| `hasOrganizationGuard` | Fabrique CanActivateFn | Redirige quand aucun contexte d'organisation actif n'est présent |
| `hasPermissionGuard` | Fabrique CanActivateFn | Redirige quand l'utilisateur ne dispose pas de la permission spécifiée |
| `SignInButton` | composant standalone | Sélecteur xid-sign-in-button ; entrées signInUrl, redirectUrl, ariaLabel |
| `SignOutButton` | composant standalone | Sélecteur xid-sign-out-button ; entrées sessionId, redirectUrl, ariaLabel; affiche aria-busy pendant la déconnexion |

Source: https://xid.dev/fr/sdks/angular/index.mdx