Aller au contenu

Composants embarqués

En cours de complément. Les composants sont les vrais écrans de LexOpti : <lexopti-client> affiche la page d’un client, <lexopti-case> celle d’un dossier, <lexopti-clients> et <lexopti-cases> les listes, et <lexopti-app> LexOpti lui-même avec sa navigation ; <lexopti-new-client> et <lexopti-new-case> les formulaires de nouveau client et de nouveau dossier de LexOpti, remplis depuis votre page.

Les composants LexOpti sont des éléments personnalisés. Chacun pilote une iframe servie par https://embed.lexopti.com : votre page ne voit jamais les données ni les jetons LexOpti, seulement la hauteur du composant et quelques événements. Pour composer la balise d’un composant et son code HTML ou React, et le voir en direct dans l’un de vos bacs à sable, utilisez l’atelier.

  • Votre application est une intégration LexOpti : un client OAuth lié à la ressource embarquée, et les origines des pages qui affichent les composants enregistrées comme ses origines embarquées (exactement https://hôte[:port] sur un nom de domaine public, jamais une adresse IP ni un nom intranet sans point ; y compris chaque page qui en encadre une autre, 10 au plus). Hors production, les origines localhost et *.localhost sont aussi acceptées, en HTTP ou en HTTPS.
  • Le membre a relié LexOpti à votre application (consentement OAuth pour son organisation), avec la portée lexopti:write que demande POST /v1/embed-sessions.
<script
type="module"
src="https://embed.lexopti.com/embed/v1.0.0.js"
integrity="sha384-2N9mNdBzYHj8ZSUxBaHxKXNPRwcwlKcJQ7PopEKhcDnoKBmAJ8RVKFcn4FXAOWTZ"
crossorigin="anonymous"
></script>

Chaque version du script est un fichier qui ne change jamais, /embed/v1.<mineure>.<correctif>.js, mis en cache un an. Son attribut integrity porte l’empreinte SHA-384 du fichier (Subresource Integrity) : le navigateur la vérifie avant d’exécuter le script et refuse un fichier qui n’y correspond pas. Avec integrity, un script d’une autre origine demande crossorigin="anonymous" ; LexOpti le sert avec Access-Control-Allow-Origin: * et Cross-Origin-Resource-Policy: cross-origin.

Une version publiée ne change plus jamais d’un octet : l’empreinte que vous épinglez aujourd’hui reste valable tant que la version est servie. LexOpti tient un registre des versions publiées et de leur empreinte, auquel on ne fait qu’ajouter ; chaque modification du script est vérifiée contre lui, et une correction sort toujours dans une nouvelle version, jamais en nouveaux octets d’une version existante.

Chaque version et son empreinte figurent dans https://embed.lexopti.com/embed/v1/manifest.json, latest étant la plus récente. Pour vérifier une empreinte vous-même : curl -s https://embed.lexopti.com/embed/v1.0.0.js | openssl dgst -sha384 -binary | openssl base64 -A.

https://embed.lexopti.com/embed/v1.js est l’alias mobile : toujours la dernière version v1, mis en cache cinq minutes, sans integrity puisque ses octets changent à chaque version. Il apporte les corrections sans rien changer de votre côté, comme Shopify sert son script App Bridge ; une version épinglée ne change que lorsque vous changez sa balise. Stripe versionne Connect.js dans son chemin (/v1.0/connect.js) sans empreinte ; LexOpti propose les deux.

Quel que soit le script chargé, v1 ne reçoit que des changements compatibles : un attribut, un événement ou un type de v1 n’est jamais retiré ni modifié.

Un script qui ne se charge pas laisse chaque composant vide et muet : donnez à votre page son propre message (Quand le script ne se charge pas).

<lexopti-client
integration="VOTRE_IDENTIFIANT_PUBLIC"
client="IDENTIFIANT_CLIENT_LEXOPTI"
tab="classification"
></lexopti-client>
<lexopti-case
integration="VOTRE_IDENTIFIANT_PUBLIC"
case="IDENTIFIANT_DOSSIER_LEXOPTI"
></lexopti-case>
<lexopti-clients integration="VOTRE_IDENTIFIANT_PUBLIC"></lexopti-clients>
<lexopti-cases integration="VOTRE_IDENTIFIANT_PUBLIC"></lexopti-cases>
<lexopti-app
integration="VOTRE_IDENTIFIANT_PUBLIC"
path="/dashboard"
></lexopti-app>
Attribut Signification
integration L’identifiant public de votre intégration (renvoyé par POST /v1/embed-sessions dans integration)
client Sur <lexopti-client> : l’identifiant du client LexOpti (depuis l’API, ou votre correspondance enregistrée)
external-ref Sur <lexopti-new-client> et <lexopti-client> : votre propre identifiant du client ; sur <lexopti-new-case> et <lexopti-case> : votre propre identifiant du dossier. L’external_ref de l’API (1 à 255 caractères parmi A-Z a-z 0-9 : . _ -, un identifiant technique opaque, jamais une donnée personnelle). Ci-dessous et ci-dessous
case Sur <lexopti-case> : l’identifiant du dossier LexOpti ; il l’emporte sur external-ref
path Sur <lexopti-app>, facultatif : l’écran sur lequel il s’ouvre (ci-dessous). Sans lui, ou avec un chemin qu’il n’affiche pas, le tableau de bord, avec un avertissement dans la console de votre page
height Facultatif, en pixels : une hauteur fixe ; l’écran défile alors à l’intérieur
display Facultatif : inline (par défaut), panel ou fullscreen (modes d’affichage)
locale fr ou en ; par défaut en quand le lang de votre page commence par en, fr sinon
header Facultatif : false masque l’en-tête et le parcours de l’écran (fil d’Ariane, carte de titre, état, étapes, barre d’onglets) sur <lexopti-client>, <lexopti-case>, <lexopti-new-client>, <lexopti-new-case> et les pages de <lexopti-app>, en gardant le contenu et ses actions ; affichés par défaut. <lexopti-classification> les masque par défaut : true affiche ceux du dossier ou du client au-dessus du questionnaire. Appliqué à chaud
tab Facultatif : l’onglet sur lequel l’écran s’ouvre, un des siens (tableau ci-dessous). Un onglet inconnu, ou que le composant n’affiche pas, ouvre le premier onglet restant, avec un avertissement dans la console de votre page. Les listes et <lexopti-app> n’ont pas d’onglet à eux : il y est ignoré, avec un avertissement (donnez l’onglet dans le path de <lexopti-app>)
features Facultatif : les parties à garder, des clés séparées par des virgules (tableau ci-dessous). Il ne peut que retirer des parties à celles que votre serveur a gardées dans la session, jamais en ajouter ; une clé inconnue est ignorée, avec un avertissement
embed-url Réservé aux environnements de test LexOpti

Le composant se charge dès que integration est renseigné, ainsi que son client ou son case pour la page d’un client ou d’un dossier (ou, sur <lexopti-client> et <lexopti-case>, son external-ref).

<lexopti-new-client> affiche dans votre page le formulaire de nouveau client de LexOpti lui-même. Votre page propose ce qu’elle sait du contact avec la propriété prefill (jamais un attribut : elle ne passe jamais dans une URL) ; le membre la vérifie, la complète et crée le client. Rien n’est enregistré dans LexOpti avant que le membre clique sur le bouton de création.

<lexopti-new-client
integration="VOTRE_IDENTIFIANT_PUBLIC"
external-ref="crm:contact:1042"
></lexopti-new-client>
<script type="module">
const form = document.querySelector("lexopti-new-client");
form.sessionProvider = sessionProvider;
form.prefill = {
type: "person",
person: {
first_name: "Camille",
last_name: "Durand",
birth_date: "1984-03-12",
nationalities: ["FR"],
},
address: {
line: "1 rue de la République",
postal_code: "69001",
city: "Lyon",
country: "FR",
},
};
form.addEventListener("lexopti-client-created", (event) => {
// event.detail = { clientId, externalRef }
});
</script>

prefill a la forme du corps de POST /v1/clients, sans external_ref :

Champ Valeurs
type person ou company, obligatoire : sans lui, rien n’est rempli
person first_name, last_name, usage_name, birth_date (AAAA-MM-JJ), birth_city, birth_country, nationalities (codes ISO 3166-1 alpha-2, 10 au plus)
company name, siren (9 chiffres), siret (14 chiffres), legal_form, registration_country, rcs
address line, postal_code, city, country (celui d’une personne seulement, comme dans l’API)

LexOpti vérifie chaque champ à part, avec la règle de l’API : un champ valide remplit le formulaire ; une valeur invalide, une clé inconnue ou la section de l’autre type est ignorée, et la console de votre page dit lesquelles (un seul avertissement qui les liste). Ce sont des données JSON simples, 16 Kio au plus. Renseignez-la avant que le formulaire s’ouvre, idéalement avec l’élément : elle est lue une fois, à l’ouverture de la session.

Avec external-ref, le nouveau client est lié à votre identifiant pour votre application lors de sa création, comme le fait POST /v1/clients avec external_ref, dans la même transaction : une référence déjà liée à un autre client ne crée rien. Si votre identifiant est déjà lié quand le formulaire s’ouvre, le composant affiche ce client (« Déjà dans LexOpti », avec son nom et un lien vers lui dans LexOpti) au lieu d’en créer un second. Un autre external-ref charge un autre formulaire. Sans external-ref, le client est créé sans référence ; liez-le ensuite avec PUT /v1/clients/{id}/external-ref.

<lexopti-client external-ref="…"> (sans client) affiche le client auquel votre identifiant est lié. Tant qu’aucun ne l’est, il le dit (« Pas encore dans LexOpti ») et, si la session garde edit, propose « Créer le client » : le même formulaire, rempli depuis le prefill de l’élément, lié à votre identifiant, après quoi la page du client s’ouvre dans le composant. Quand les deux sont renseignés, client l’emporte.

Une fois que <lexopti-client> affiche un client, son prefill propose des modifications de l’identité de ce client, de la même forme (type peut être omis ; un autre type que celui du client est ignoré en entier). Quand la session garde edit, la page du client ouvre son onglet « Informations » avec les champs proposés remplis dans son vrai formulaire de modification et un bandeau qui dit combien : le membre les vérifie, puis enregistre (les règles de l’application : un client analysé garde ses champs obligatoires, la modification d’un champ analysé en vigilance continue relance son analyse) ou les ignore. Rien n’est écrit avant que le membre enregistre ; client.updated le dit alors à votre serveur. Les champs déjà égaux à ceux du client ne sont pas des propositions. Chaque champ ignoré est signalé dans la console. Votre serveur peut aussi modifier une identité lui-même par PATCH /v1/clients/{id}.

Un nouveau client est un brouillon : aucune vérification ne part et aucun crédit n’est dépensé tant que le membre ne lance pas ses analyses depuis sa page. La session du composant est component: "new-client", sans features (le formulaire n’a aucune partie à garder : toute clé répond 400 invalid_features).

<lexopti-new-case> affiche dans votre page l’écran « Nouveau dossier » de LexOpti lui-même, celui de l’application : ses natures, ses clients et ses parties, ses contrôles. Votre page propose le dossier avec la propriété prefill (jamais un attribut, jamais dans une URL) ; le membre le vérifie, le complète et le crée. Rien n’est enregistré dans LexOpti avant que le membre clique sur le bouton de création.

<lexopti-new-case
integration="VOTRE_IDENTIFIANT_PUBLIC"
external-ref="crm:matter:7"
></lexopti-new-case>
<script type="module">
const form = document.querySelector("lexopti-new-case");
form.sessionProvider = sessionProvider;
form.prefill = {
label: "Acquisition des locaux PRESSE Conseil",
case_types: ["custom"],
custom_case_type_label: "Acquisition de locaux professionnels",
parties: [
// Un client de la structure, lié à votre contact, par votre référence.
{ external_ref: "crm:contact:1042", role: "client" },
// Le vendeur, son identité et votre référence (celle d’une partie).
{
external_ref: "crm:contact:2001",
identity: {
type: "company",
company: { name: "PRESSE Conseil SAS", siren: "552100554" },
},
role: "vendeur",
},
],
};
form.addEventListener("lexopti-case-created", (event) => {
// event.detail = { caseId, externalRef }
});
</script>
Champ Valeurs
label Le titre du dossier, 1 à 255 caractères ; sans lui, LexOpti l’écrit depuis les natures et le client
case_types Les natures du dossier, parmi celles que LexOpti propose à la profession de l’organisation ; custom avec custom_case_type_label (2 à 160 caractères), la nature libre de toutes les professions
parties 20 au plus, chacune avec un seul de client_id (un client LexOpti), external_ref (votre référence d’un client, pour votre application) ou identity (une personne à créer, de la forme du prefill de nouveau client, nommée), un role facultatif et, avec identity, un external_ref facultatif : le client (rôle client) ou la partie que votre référence désigne déjà est repris, sinon le nouveau est créé depuis l’identité et lié à elle

role vaut client par défaut : un client du dossier, le premier son client principal (un client existant, par son identifiant ou votre référence, ou un nouveau client créé avec le dossier depuis son identity). Tout autre rôle est une partie du dossier, créée depuis son identity, parmi les rôles que la profession de l’organisation propose (Concepts, « Rôles des parties ») ; un client existant n’est proposé que comme client du dossier : avec un autre rôle, il est écarté et signalé (une partie n’est jamais un client existant, puisque les obligations du professionnel envers ses clients suivraient). LexOpti vérifie chaque champ à part : une nature ou un rôle que la profession ne propose pas, un identifiant ou une référence de client inconnus, une identité sans son nom, une clé inconnue ou une valeur invalide est ignoré (un rôle de partie que la profession ne propose pas prend celui du formulaire par défaut, autre), et la console de votre page dit lesquels en un seul avertissement. Ce sont des données JSON simples, 16 Kio au plus, lues une fois à l’ouverture du formulaire.

Avec external-ref, le nouveau dossier est lié à votre identifiant pour votre application dans la transaction de sa création : une référence déjà liée à un autre dossier ne crée aucun dossier. Si votre identifiant est déjà lié quand le formulaire s’ouvre, le composant affiche ce dossier (« Déjà dans LexOpti », avec un lien vers lui dans LexOpti) au lieu d’en créer un second ; la référence est relue avant toute création. Le formulaire crée d’abord les nouveaux clients, puis le dossier et ses parties, comme dans LexOpti : si un autre dossier prend votre identifiant dans l’instant entre cette relecture et la création, aucun dossier n’est créé, le formulaire le dit, et les nouveaux clients restent dans LexOpti en brouillon (comme quand la création d’un dossier échoue dans LexOpti même). La référence est celle de votre application, dans l’organisation du membre : comme celle de <lexopti-new-client>, elle n’est pas liée à la session, donc toute page que votre fournisseur de session sert peut nommer n’importe lequel de vos identifiants ; seul un membre de l’organisation, par votre application, crée quoi que ce soit.

<lexopti-case external-ref="…"> (sans case) affiche le dossier auquel votre identifiant est lié. Tant qu’aucun ne l’est, il le dit (« Pas encore dans LexOpti ») et, si la session garde edit, propose de le créer : le même formulaire, rempli depuis le prefill de l’élément, lié à votre identifiant, après quoi la page du dossier s’ouvre dans le composant. Quand les deux sont renseignés, case l’emporte.

Un nouveau dossier est facturé à sa création, comme dans LexOpti : son dossier s’ouvre (un crédit par tranche de cinq personnes ou sociétés, ce qu’une confirmation indique avant la création du dossier), rien n’est analysé tant que le membre ne lance pas ses analyses depuis sa page, gratuitement dans ses places ; une organisation dont l’abonnement est inactif reçoit le refus de LexOpti lui-même (son abonnement s’ouvre dans LexOpti). La session du composant est component: "new-case", sans features. Votre serveur peut aussi créer un dossier lui-même avec POST /v1/cases (créer un dossier depuis votre fiche).

<lexopti-clients> et <lexopti-cases> affichent les listes des clients et des dossiers de l’organisation comme dans LexOpti, avec leur recherche, leurs filtres et leurs vues. Une ligne ouvre la page du client ou du dossier dans le composant. Dans <lexopti-clients>, « Nouveau client » ouvre le formulaire de nouveau client de LexOpti dans le composant tant que la session garde edit (sans lui, la liste n’offre aucune création) ; une fois le client créé, sa page s’y ouvre et l’élément envoie lexopti-client-created (externalRef à null : la liste ne nomme aucune référence ; liez le client à votre fiche par l’API, PUT /v1/clients/{id}/external-ref). Un nouveau dossier s’ouvre dans LexOpti, dans un nouvel onglet.

<lexopti-app> affiche LexOpti lui-même dans votre page, avec sa navigation réduite à trois entrées : tableau de bord, dossiers et clients (ni sélecteur d’organisation, ni entrée de l’organisation ; l’aide et la cloche des notifications restent). La cloche est celle de LexOpti : les notifications du membre dans la seule organisation liée (aucune sur les commentaires quand la session laisse comments de côté), chacune ouvrant la page de son client ou de son dossier dans le composant (une mention sur son commentaire), toute autre dans LexOpti, dans un nouvel onglet. Marquer les notifications comme lues ne demande que lexopti:read, c’est l’état de lecture du membre ; les supprimer demande lexopti:write, et sans lui la cloche n’affiche aucun bouton de suppression. Ses écrans, valeurs de path et de navigate() :

Chemin Écran
/dashboard Le tableau de bord : alertes, activité, dossiers et clients sous vigilance continue
/clients, /cases Les listes
/clients/<id>, /cases/<id> La page d’un client ou d’un dossier, avec ?tab=<onglet> pour un de ses onglets
/clients/new, /cases/new Les formulaires de nouveau client et de nouveau dossier (avec edit)

Ce qui exige la fenêtre de LexOpti s’ouvre dans LexOpti, dans un nouvel onglet : l’abonnement et le paiement, les réglages de l’organisation (membres, applications connectées), l’administration de la plateforme, le compte et la sécurité du membre, et la double authentification. Ses entrées « Nouveau dossier » (le tableau de bord, la liste des dossiers, les dossiers d’un client) y ouvrent le formulaire de nouveau dossier tant que la session garde edit, le client déjà choisi depuis la page d’un client.

<lexopti-classification> affiche le questionnaire de classification des risques d’un client (client) ou d’un dossier (case, prioritaire) nu : ses questions et ses réponses seules, sans la page autour, sans rail d’onglets, sans panneau de score. Avec axis, un seul axe du questionnaire d’un dossier (axe1 l’entrée en relation, axe2 le client, axe3 le service, axe4 l’opération), pour que votre page place les axes l’un après l’autre, chacun dans son élément ; le questionnaire d’un client n’a que axe2, les autres axes affichent une ligne d’avertissement. axis s’applique à chaud. L’enregistrement, la finalisation et l’impact sur les dossiers validés sont ceux de LexOpti, exactement comme dans sa fenêtre ; les variables de thème s’appliquent comme sur chaque composant.

<lexopti-classification
integration="YOUR_PUBLIC_ID"
case="LEXOPTI_CASE_ID"
axis="axe1"
></lexopti-classification>
<lexopti-classification
integration="YOUR_PUBLIC_ID"
case="LEXOPTI_CASE_ID"
axis="axe2"
></lexopti-classification>

Chaque élément a besoin de sa propre session (component : classification) ; il n’a pas de features et n’affiche rien d’autre : un lien vers un autre écran de LexOpti ouvre LexOpti dans un nouvel onglet.

Le composant demande une session au démarrage, puis chaque fois que son jeton expire (environ toutes les 10 minutes). Donnez-lui une fonction qui demande un code à usage unique à votre serveur. Le composant l’appelle avec un défi PKCE (codeChallenge, codeChallengeMethod: "S256") et son propre nom (component : client pour <lexopti-client>, case pour <lexopti-case>, clients, cases et app pour les listes et <lexopti-app>, classification pour <lexopti-classification>) : transmettez-les tels quels. Une session n’ouvre qu’un seul composant.

const element = document.querySelector("lexopti-client");
element.sessionProvider = async ({
codeChallenge,
codeChallengeMethod,
component,
}) => {
const response = await fetch("/votre-serveur/lexopti-embed-session", {
body: JSON.stringify({ codeChallenge, codeChallengeMethod, component }),
headers: { "content-type": "application/json" },
method: "POST",
});
return { code: (await response.json()).code };
};

Votre serveur appelle POST https://app.lexopti.com/v1/embed-sessions avec le jeton d’accès du membre et { "origin": "<l’origine de la page qui affiche le composant>", "code_challenge": "<codeChallenge>", "code_challenge_method": "S256", "component": "<component>" }, puis renvoie le code (usage unique, valable 60 secondes). Ne le mettez jamais en cache. L’iframe l’échange elle-même, avec le vérificateur PKCE qu’elle seule détient : un code lu ailleurs (un journal, une extension, un autre cadre) ne peut pas être échangé. Le jeton obtenu reste dans l’iframe.

Un élément garde un fournisseur posé avant que le script l’ait défini, quel que soit l’ordre de vos scripts. Vous pouvez aussi donner à la page un fournisseur unique, qui sert tout composant sans le sien, posé avant ou après le chargement du script :

window.LexOpti = {
sessionProvider: async ({
codeChallenge,
codeChallengeMethod,
component,
}) => {
const response = await fetch("/votre-serveur/lexopti-embed-session", {
body: JSON.stringify({ codeChallenge, codeChallengeMethod, component }),
headers: { "content-type": "application/json" },
method: "POST",
});
return { code: (await response.json()).code };
},
};

Une session ouvre le seul composant qui l’a demandée, comme les sessions de compte de Stripe : une session pour <lexopti-client> ne sert jamais un autre composant, et LexOpti refuse ses appels venant de tout autre. Disponibles : client, case, clients, cases, app, new-client, new-case et classification. Les listes et <lexopti-app> n’affichent que les clients, les dossiers, les alertes et l’activité de l’organisation liée, compteurs compris.

Votre serveur peut aussi ne garder que certaines parties du composant avec features, une liste de clés stables dans la demande de session ("features": ["monitoring", "classification", "launch-check"]) ; omise, le composant est complet. Une clé d’un autre composant répond 400 invalid_features. L’attribut features du composant peut ensuite en retirer d’autres, dans la page et à chaud, jamais en ajouter : les parties affichées sont celles de la session que l’attribut nomme aussi. Les droits du membre s’appliquent en plus (un membre en lecture seule ne lance et ne modifie rien).

Une partie retirée ne laisse aucune trace : son onglet n’est pas dans la barre d’onglets et ne se charge jamais, ses boutons et ses menus sont absents, et les gabarits de chargement prennent la mise en page réduite. Un écran sans aucun onglet affiche son en-tête et indique que la page n’a gardé aucun de ses onglets, avec un lien pour l’ouvrir dans LexOpti. Quoi que fasse la page, LexOpti refuse les appels des parties que vous retirez (403 feature_disabled).

Composant Onglets Actions
client, clients monitoring, cases, classification, informations, comments, activity launch-check, edit
case, cases parties, tracfin2, documents, comments, activity launch-check, edit
app Les onglets des deux pages : monitoring, cases, classification, informations, comments, activity, parties, tracfin2, documents launch-check, edit

Une liste a les clés de la page que ses lignes ouvrent. Dans <lexopti-app>, les deux pages s’ouvrent depuis la navigation : un onglet retiré disparaît de sa page, et cases ou parties n’empêchent plus l’autre page de s’ouvrir. Là, cases, parties et informations ne font que masquer leur onglet : LexOpti ne refuse rien pour eux, puisque l’autre page et la fiche du client (le formulaire de nouveau client aussi) restent ouvertes depuis la navigation ; les modifications du client et du dossier relèvent toujours de edit. activity retire aussi le fil d’activité du tableau de bord.

Le premier onglet est celui sur lequel un écran s’ouvre par défaut. Ce que fait le retrait de chaque clé :

Clé La retirer
Un onglet Masque l’onglet ; LexOpti refuse ce que cet onglet appelle seul
cases (client) En plus : les dossiers du client ne s’ouvrent jamais dans le composant, ses liens vers eux n’affichent que leur texte, et les rapports de ses dossiers sont refusés
parties (dossier) En plus : les clients du dossier ne s’ouvrent jamais dans le composant, et ses liens vers eux n’affichent que leur texte
comments, activity Masque l’onglet aussi sur l’autre écran que le composant ouvre (le dossier d’un client, le client d’un dossier). Sans comments, l’activité n’affiche pas non plus de commentaire
informations (client) Masque la fiche du client ; ses enregistrements relèvent de edit
launch-check Aucun lancement : les boutons de lancement disparaissent, et LexOpti refuse tout chemin qui lancerait une analyse, y compris la réactivation de la vigilance continue (d’un client ou d’une partie d’un dossier) et la modification d’une identité qui l’analyserait à nouveau (rien n’est alors enregistré)
edit Aucune modification : l’identité, ses liens, le titre, les parties et les collaborateurs d’un dossier se lisent seulement ; la fiche du client s’affiche sans que ses champs se saisissent. Dans les listes et <lexopti-app>, aucune entrée de création non plus, ni formulaire de nouveau client ou de nouveau dossier ; un <lexopti-case> dont l’external-ref n’est pas lié ne propose aucune création

Enregistrez les déclarations à côté de votre code, sous ces noms (le fichier Vue importe le premier) :

Fenêtre de terminal
curl -o src/types/lexopti-embed.d.ts https://embed.lexopti.com/embed/v1.d.ts
curl -o src/types/lexopti-embed-vue.d.ts https://embed.lexopti.com/embed/v1/vue.d.ts

lexopti-embed.d.ts type chaque élément dans document.querySelector et document.createElement (LexoptiClientElement, LexoptiCaseElement, LexoptiClientsElement, LexoptiCasesElement, LexoptiAppElement, LexoptiNewClientElement, LexoptiNewCaseElement), ses attributs (LexoptiClientAttributes…, le path de <lexopti-app> en LexoptiScreenPath), sessionProvider et sa demande (LexoptiSessionRequest), prefill (LexoptiClientPrefill, le corps de POST /v1/clients ; LexoptiCasePrefill pour un nouveau dossier), navigate(), refresh(), window.LexOpti, et chaque événement dans addEventListener, détail compris (LexoptiEvent<"check-completed">). Comme le script, il ne reçoit que des changements compatibles au sein de v1.

React 19 affiche lui-même les éléments personnalisés (la référence de React) : dans le navigateur, il pose une prop comme propriété quand l’élément en a une, comme attribut sinon, et écoute on<événement> sous le nom exact de l’événement ; sur le serveur, il rend les chaînes et les nombres en attributs et omet les fonctions. Un sessionProvider rendu avant que le script ait défini les éléments serait perdu : c’est pourquoi les composants React existent.

Fenêtre de terminal
npm install @lexopti/embed-react
import { LexoptiClient } from "@lexopti/embed-react";
import type { LexoptiSessionProvider } from "@lexopti/embed-react";
import { useState } from "react";
const sessionProvider: LexoptiSessionProvider = async (request) => {
const response = await fetch("/votre-serveur/lexopti-embed-session", {
body: JSON.stringify(request),
headers: { "content-type": "application/json" },
method: "POST",
});
return { code: (await response.json()).code };
};
export function ClientCompliance({ clientId }: { clientId: string }) {
const [display, setDisplay] = useState<"fullscreen" | "inline" | "panel">(
"inline"
);
return (
<>
<button type="button" onClick={() => setDisplay("panel")}>
Ouvrir dans un panneau
</button>
<LexoptiClient
integration="VOTRE_IDENTIFIANT_PUBLIC"
client={clientId}
tab="classification"
features={["monitoring", "classification", "comments"]}
display={display}
sessionProvider={sessionProvider}
onDisplayChanged={(event) => setDisplay(event.detail.mode)}
onCheckCompleted={(event) => {
// Rafraîchissez ici votre propre vue du client.
console.log(event.detail.outcome);
}}
/>
</>
);
}

<LexoptiClient>, <LexoptiCase>, <LexoptiClients>, <LexoptiCases>, <LexoptiApp> (son path changé en direct) <LexoptiNewClient> (externalRef, prefill donné comme propriété, onClientCreated) et <LexoptiNewCase> (de même avec onCaseCreated ; <LexoptiClient> et <LexoptiCase> prennent aussi externalRef et prefill) affichent la balise (la page charge toujours le script, étape 2) : leurs props sont les attributs, typés (tab, features en liste, height en nombre, embedUrl), sessionProvider, transmis à l’élément même avant sa définition, et une prop on… par événement (onReady, onCheckCompleted, onDisplayChanged…), qui reçoit l’événement DOM. Leur ref est l’élément, pour navigate() et refresh(). Le rendu serveur est sûr : rien ne lit window pendant le rendu, le serveur envoie la balise et ses attributs, le script la met à niveau dans le navigateur. Gardez display dans votre état et mettez-le à jour depuis onDisplayChanged, puisque le membre ferme le panneau. Sans ces composants, écrivez la balise vous-même : <lexopti-client onlexopti-check-completed={…}>, et donnez le fournisseur par window.LexOpti.

Vue 3 pose une liaison comme propriété quand l’élément en a une, comme attribut sinon, .prop imposant une propriété (le guide de Vue). Indiquez à son compilateur que les balises sont des éléments personnalisés :

vite.config.ts
import vue from "@vitejs/plugin-vue";
import { defineConfig } from "vite";
export default defineConfig({
plugins: [
vue({
template: {
compilerOptions: {
isCustomElement: (tag) => tag.startsWith("lexopti-"),
},
},
}),
],
});

Passez ensuite le fournisseur avec .prop (une fonction n’est jamais un attribut) et écoutez les événements sous leur nom :

<script setup lang="ts">
import type {
LexoptiEvent,
LexoptiSessionProvider,
} from "../types/lexopti-embed";
defineProps<{ clientId: string }>();
const sessionProvider: LexoptiSessionProvider = async (request) => {
const response = await fetch("/votre-serveur/lexopti-embed-session", {
body: JSON.stringify(request),
headers: { "content-type": "application/json" },
method: "POST",
});
return { code: (await response.json()).code };
};
function onCheckCompleted(event: LexoptiEvent<"check-completed">) {
// Rafraîchissez ici votre propre vue du client.
console.log(event.detail.outcome);
}
</script>
<template>
<lexopti-client
integration="VOTRE_IDENTIFIANT_PUBLIC"
:client="clientId"
tab="classification"
:session-provider.prop="sessionProvider"
@lexopti-check-completed="onCheckCompleted"
/>
</template>

Avec lexopti-embed-vue.d.ts dans votre projet, vue-tsc vérifie les attributs (tab="nope" est une erreur) et déduit le détail de chaque événement. Il suit le modèle de Vue lui-même, une entrée GlobalComponents par balise.

Angular refuse les éléments inconnus, sauf si le composant déclare CUSTOM_ELEMENTS_SCHEMA (le guide d’Angular). Liez les attributs avec [attr.…] : une liaison [client] simple poserait une propriété, que l’élément ne lit pas. Liez sessionProvider comme propriété :

import {
Component,
CUSTOM_ELEMENTS_SCHEMA,
input,
signal,
} from "@angular/core";
import type {
LexoptiDisplayMode,
LexoptiEvent,
LexoptiSessionProvider,
} from "../types/lexopti-embed";
@Component({
selector: "app-client-compliance",
schemas: [CUSTOM_ELEMENTS_SCHEMA],
template: `
<lexopti-client
integration="VOTRE_IDENTIFIANT_PUBLIC"
[attr.client]="clientId()"
tab="classification"
[attr.display]="display()"
[sessionProvider]="sessionProvider"
(lexopti-display-changed)="onDisplayChanged($event)"
(lexopti-check-completed)="onCheckCompleted($event)"
></lexopti-client>
`,
})
export class ClientComplianceComponent {
readonly clientId = input.required<string>();
readonly display = signal<LexoptiDisplayMode>("inline");
readonly sessionProvider: LexoptiSessionProvider = async (request) => {
const response = await fetch("/votre-serveur/lexopti-embed-session", {
body: JSON.stringify(request),
headers: { "content-type": "application/json" },
method: "POST",
});
return { code: (await response.json()).code };
};
onDisplayChanged(event: LexoptiEvent<"display-changed">): void {
this.display.set(event.detail.mode);
}
onCheckCompleted(event: LexoptiEvent<"check-completed">): void {
// Rafraîchissez ici votre propre vue du client.
console.log(event.detail.outcome);
}
}

Avec lexopti-embed.d.ts dans le programme, la vérification stricte des gabarits (strictTemplates, la référence d’Angular) type $event de chaque événement lexopti-… ; Angular ne vérifie pas les liaisons de propriétés et d’attributs des éléments personnalisés.

En-tête Ce que demandent les composants
Content-Security-Policy script-src https://embed.lexopti.com
frame-src https://embed.lexopti.com
style-src, connect-src, img-src, font-src Rien de plus : l’élément met en forme sa racine fantôme fermée par une feuille de style construite (adoptedStyleSheets), que style-src ne régit pas, donc sans 'unsafe-inline' ; il ne charge rien lui-même ; les requêtes, images et polices de l’écran sont celles de son iframe, sous la politique de LexOpti. Votre sessionProvider appelle votre propre serveur
Cross-Origin-Opener-Policy Toute valeur, same-origin comprise : chaque nouvel onglet ouvert par le composant (LexOpti, un PDF, la facturation) s’ouvre avec noopener, et aucun parcours n’a besoin d’y accéder
Cross-Origin-Embedder-Policy Ne le posez pas : sous require-corp ou credentialless, les navigateurs refusent une iframe d’une autre origine qui n’envoie pas cet en-tête elle-même, et celle du composant ne l’envoie pas

Les composants utilisent des feuilles de style construites, disponibles dans tous les navigateurs depuis mars 2023 (Chrome 73, Firefox 101, Safari 16.4).

Ne placez pas le composant dans une iframe sandboxée de votre côté sans allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox allow-downloads : une iframe imbriquée n’obtient jamais une permission que son parent n’a pas.

Le script pèse environ 8 Ko compressé et ne fait que définir les éléments ; chaque composant charge ensuite son propre écran dans son iframe, en différé : l’iframe porte loading="lazy", si bien qu’un composant loin sous la ligne de flottaison se charge quand le membre s’en approche. LexOpti tient l’écran de chaque composant dans un budget de taille, vérifié à chaque build.

Quand votre page insère un composant tardivement (une route d’une application monopage, un tiroir), préparez les connexions dans son <head> :

<link rel="preconnect" href="https://embed.lexopti.com" />
<link
rel="modulepreload"
href="https://embed.lexopti.com/embed/v1.0.0.js"
integrity="sha384-2N9mNdBzYHj8ZSUxBaHxKXNPRwcwlKcJQ7PopEKhcDnoKBmAJ8RVKFcn4FXAOWTZ"
crossorigin="anonymous"
/>

modulepreload récupère le script à l’avance, avec son empreinte, sur la connexion anonyme qu’utilise un module ; preconnect, sans crossorigin, ouvre la connexion qu’utilise l’iframe. Ensuite :

  • ne chargez le script que sur les pages qui affichent un composant ;
  • montez un composant une fois et gardez-le : chaque montage ouvre une session et recharge son écran, alors que navigate(), tab et display le changent sans rechargement ;
  • laissez le composant afficher son propre squelette de chargement, à la forme de son écran : si votre page affiche son propre substitut avant l’exécution du script, masquez-le sur lexopti-ready.

La même iframe s’affiche de trois façons ; elle ne bouge ni ne se recharge entre elles, l’écran garde donc son état.

display Affiche Se ferme
inline (par défaut) Dans votre page, à la hauteur de son contenu, ou à height avec l’écran qui défile à l’intérieur
panel Un panneau latéral à droite de la fenêtre, de 720 px de large au plus, par-dessus votre page ; sous 640 px de large, en plein écran Échap, son bouton de fermeture, un clic sur le fond
fullscreen Toute la fenêtre, par-dessus votre page Échap, son bouton de fermeture

Posez l’attribut pour ouvrir le panneau ou le plein écran ; quand le membre le ferme, l’élément remet display="inline" et émet lexopti-display-changed avec le mode qu’il affiche (fullscreen pour un panneau sur un écran étroit). En React, gardez le mode dans votre état et mettez-le à jour depuis cet événement.

Les boîtes de dialogue et les panneaux de l’écran restent dans la zone qu’occupe le composant (overlays="contained", par défaut) : en ligne et à la hauteur de son contenu, le composant se borne à sa partie visible (320 px au moins, dans la fenêtre de votre page ou dans le conteneur qui défile autour de lui) tant qu’une boîte de dialogue est ouverte, se fait voir, et la boîte s’affiche là ; l’écran défile à l’intérieur pendant ce temps, et le composant reprend la hauteur de son contenu quand la dernière se ferme. Avec overlays="fullscreen", le composant passe en plein écran dans votre page tant qu’une boîte de dialogue est ouverte et revient en ligne quand elle se ferme, comme avant. Le protocole suit MCP Apps : l’iframe déclare les modes qu’elle prend en charge, l’élément ceux qu’il propose (availableDisplayModes), et une demande d’un autre mode garde le mode courant.

Définissez ces variables CSS sur l’élément (ou un ancêtre, ou une règle de feuille de style sur tous les éléments lexopti-… de votre page). Chacune s’applique à l’un des jetons de design de LexOpti ; l’atelier les compose avec une roue de couleurs, des curseurs et un sélecteur de polices, et écrit la règle exacte. Couleurs (hexadécimal, rgb(), oklch()…) et longueurs uniquement ; le reste (url(), var(), échappements, plus de 64 caractères) est ignoré :

Variable Rôle
--lexopti-accent Boutons, liens, onglet actif, entrée active de la navigation
--lexopti-accent-foreground Texte sur l’accent (le libellé d’un bouton principal)
--lexopti-background Le fond de l’écran et de ses fenêtres surgissantes
--lexopti-foreground Texte
--lexopti-card Cartes (et la navigation de <lexopti-app>)
--lexopti-card-foreground Texte des cartes
--lexopti-muted Surfaces secondaires : teintes, survol, boutons secondaires
--lexopti-muted-foreground Texte secondaire
--lexopti-border Bordures
--lexopti-input Les bordures des champs
--lexopti-ring L’anneau de focus
--lexopti-destructive Erreurs et alertes
--lexopti-warning Avertissements (l’ambre de la vigilance)
--lexopti-success Succès (le vert de la vigilance)
--lexopti-radius Le rayon des angles de chaque contrôle et carte (LexOpti a un seul rayon, 10px par défaut)
--lexopti-font-size Un multiplicateur de la taille du texte de l’écran, de 0.85 à 1.2 (1 par défaut) ; tout l’écran suit, espacements compris
--lexopti-font lexopti (la police de LexOpti, par défaut), system (la police d’interface du système de vos visiteurs) ou une liste font-family à vous
lexopti-client {
--lexopti-accent: #15803d;
--lexopti-radius: 6px;
--lexopti-font: Georgia, "Times New Roman", serif;
}

Les variables s’appliquent aux jetons de design de LexOpti : il n’y a ni CSS libre ni sélecteur. --lexopti-font prend un mot-clé ou une liste de noms de polices (lettres, chiffres, espaces, virgules, guillemets et tirets, 200 caractères au plus), appliquée là où vos visiteurs ont ces polices et retombant sur la famille générique qui la termine : le composant ne télécharge jamais de police. Toute autre valeur (une URL, une fonction, un échappement) est ignorée avec un avertissement dans la console de votre page. Une police externe élargirait la politique de sécurité du contenu de l’iframe et enverrait l’adresse IP du membre à un tiers.

Le composant lit les variables au démarrage et à chaque changement de son style ou de sa class. Appelez element.refreshTheme() après les avoir modifiées depuis une de vos feuilles de style. LexOpti a un seul thème, clair : les écrans ne passent jamais en sombre, quel que soit le color-scheme de votre page.

Chaque composant signale à votre page ce qui s’y passe par des événements DOM nommés lexopti-<type>, sans deux-points : en React 19, écrivez onlexopti-check-completed={…} sur l’élément. Ils remontent et traversent les shadow roots ; leur détail est dans event.detail. La liste est fermée et versionnée (version 1) : un type n’est jamais retiré ni modifié au sein d’une version. Les événements métier partent une fois la modification enregistrée par LexOpti, jamais sur un simple clic.

Événement Détail Quand
lexopti-ready { component }, component parmi client, case, clients, cases, app, new-client, new-case La session du composant est ouverte et son écran démarre : masquez votre propre indicateur de chargement
lexopti-resize { height } Le composant s’est ajusté à son écran (mise en page automatique seulement)
lexopti-navigate { path, title }, path parmi les chemins de navigate() Le membre a ouvert un autre écran ou onglet du composant ; gardez path pour y revenir avec navigate(), ou comme path de <lexopti-app>
lexopti-check-started { clientId } ou { caseId } Une analyse du client ou du dossier a été lancée
lexopti-check-completed { clientId } ou { caseId }, et outcome : completed ou failed (un contrôle a échoué) Les analyses en cours pour le client ou le dossier sont terminées
lexopti-alert-reviewed { alertId, clientId, status }, status vaut reviewed ou dismissed Le membre a traité une alerte
lexopti-classification-validated { clientId } ou { caseId } Le membre a validé l’évaluation du risque
lexopti-mention-created { commentId, clientId } ou { commentId, caseId } Dans <lexopti-app>, tant que sa cloche des notifications est affichée : un collègue a mentionné le membre dans un commentaire de ce client ou de ce dossier. Des identifiants seulement, jamais le texte du commentaire ni son auteur : lisez le commentaire dans LexOpti
lexopti-client-created { clientId, externalRef }, externalRef l’external-ref de l’élément (lié au nouveau client), null sans Le membre a créé un client : dans <lexopti-new-client>, dans un <lexopti-client> dont l’external-ref n’était pas encore lié, ou dans le formulaire de <lexopti-clients> ou de <lexopti-app> (externalRef à null). Lisez le client et sa référence par l’API (GET /v1/clients?external_ref=) plutôt que de vous fier au seul événement de la page
lexopti-case-created { caseId, externalRef }, externalRef l’external-ref de l’élément (lié à le nouveau dossier), null sans lui Le membre a créé un dossier : dans <lexopti-new-case>, dans un <lexopti-case> dont l’external-ref n’était pas encore lié, ou dans le formulaire de <lexopti-app>. Des identifiants seulement : lisez le dossier et sa référence par l’API (GET /v1/cases?external_ref=) plutôt que de vous fier au seul événement de la page
lexopti-session-ended { reason } : access_revoked, provider_failed ou expired Aucune nouvelle session ne peut être obtenue : l’accès du membre a pris fin, votre sessionProvider a échoué, ou il n’a jamais répondu
lexopti-display-changed { mode } : inline, panel ou fullscreen Le composant a changé de mode d’affichage : votre attribut display, une de ses boîtes de dialogue, ou le membre qui a fermé le panneau
lexopti-error { type, message }, type parmi session, network, not_found, forbidden, render Le composant n’a pas pu se charger (il affiche sa propre erreur et un bouton pour réessayer) : network quand le cadre a servi autre chose que le composant, session quand sa session n’a pas pu s’ouvrir (votre sessionProvider a échoué, ou LexOpti a refusé ou était injoignable ; trop de sessions ouvertes depuis un même réseau sont d’abord réessayées quelques secondes, puis le message le dit)

Rafraîchissez votre propre vue du client ou du dossier sur les événements métier (par exemple via GET /v1/clients/{id}).

Chaque analyse d’un client qu’un membre déclenche dans un écran est une analyse de votre application, comme celle que crée POST /v1/checks : vous recevez son webhook check.completed ou check.failed, et GET /v1/checks la liste. Ce sont :

  • le lancement des analyses du client, ou d’une de ses entités ;
  • la réactivation de la vigilance continue, qui analyse les entités modifiées entre-temps ;
  • la modification d’une identité, analysée à nouveau pour chaque client auquel elle appartient ;
  • le lancement des analyses d’un dossier : une analyse par client qu’il analyse.

Les analyses des tiers d’un dossier n’en sont pas : une analyse nomme un client.

Méthode ou attribut Effet
element.navigate(path) Affiche un autre écran ou onglet du composant dans l’iframe, sans la recharger : /clients/<id> ou /cases/<id>, avec ?tab=<onglet> (un onglet que la session garde) ; pour une liste, aussi son propre chemin (/clients, /cases) ; pour <lexopti-app>, tous les chemins de son tableau. Rend une promesse, rejetée pour tout autre chemin, avant lexopti-ready, ou quand le composant la refuse
element.refresh() Recharge les données de l’écran, après une modification faite par votre application de son côté. Rend une promesse
Attribut locale Modifié après le démarrage, appliqué à chaud, sans recharger l’iframe
Attribut tab Modifié après le démarrage, affiche cet onglet de l’écran propre à l’élément, sans recharger l’iframe (une fois lexopti-ready émis ; une modification antérieure s’applique alors). Le retirer laisse l’écran où il est
Attribut path Sur <lexopti-app>, modifié après le démarrage, affiche cet écran sans recharger l’iframe (une fois lexopti-ready émis ; une modification antérieure s’applique alors)
Attribut features Modifié après le démarrage, appliqué à chaud : un onglet qu’il retire laisse place au premier onglet restant
Attribut display Ouvre le panneau latéral ou le plein écran, ou le ferme (inline), sans recharger l’iframe
Attribut header Modifié après le démarrage, affiche ou masque l’en-tête et le parcours de l’écran à chaud
Variables de thème Posées sur le style ou la class de l’élément, appliquées à chaud ; posées par une de vos feuilles de style, appelez element.refreshTheme()

La fiche d’un client ouvre ses dossiers dans l’iframe, et celle d’un dossier ses clients : le composant et la session restent les mêmes. De même pour une liste et les pages que ses lignes ouvrent, et pour chaque écran de <lexopti-app>.

  • Le composant démarre à 760 px de haut (720 px pour une liste, 900 px pour <lexopti-app> et les formulaires de création, <lexopti-new-client> et <lexopti-new-case>), puis s’ajuste au contenu de son écran. Avec height, il garde cette hauteur et l’écran défile à l’intérieur.
  • Tant que sa session s’ouvre, chaque écran affiche son propre gabarit de chargement, à la mise en page de l’écran chargé, navigation de <lexopti-app> comprise.
  • Votre page n’agit jamais dans l’écran : ses clics n’atteignent jamais l’iframe, et seul le membre valide un niveau de risque.
  • Le composant n’ouvre dans un nouvel onglet que les pages de LexOpti, jamais une autre adresse.
  • Le gabarit de chargement ne connaît que l’attribut features jusqu’à l’ouverture de la session ; ensuite, les onglets que la session retire quittent aussi la barre d’onglets. Nommez dans l’attribut ce que garde votre serveur, et rien ne bouge.
  • Un composant qui affiche un PDF utilise la visionneuse de LexOpti (les navigateurs refusent la leur dans une iframe sandboxée) et propose de l’ouvrir dans un nouvel onglet.
  • Un membre qui perd l’accès (sortie de l’organisation, application bloquée ou déliée) voit une erreur à sa requête suivante ; une nouvelle session ne peut pas non plus être obtenue.
  • Quand la session du membre dans votre page prend fin après s’être ouverte (LexOpti refuse l’échange, ou votre sessionProvider refuse un nouveau code), l’écran laisse place à un message avec Ouvrir LexOpti et Réessayer, jamais à un formulaire de connexion. Avant toute session ouverte (pas de sessionProvider, un fournisseur qui échoue ou ne répond jamais), le composant affiche son erreur : la correction est de votre côté.

Quand le navigateur n’exécute pas le script, parce que ses octets ne correspondent pas à l’integrity de votre balise, que le réseau échoue ou que votre Content-Security-Policy le bloque, les balises lexopti-… restent des éléments personnalisés non définis : pas d’iframe, pas de gabarit de chargement, pas de message d’erreur, aucun événement (pas même lexopti-ready). Les messages du composant viennent du script : votre page affiche donc le sien, avec un lien vers LexOpti :

<script>
// Votre message dans chaque composant, si le script de LexOpti ne s’est pas exécuté.
function lexoptiUnavailable() {
for (const element of document.querySelectorAll(
"lexopti-app, lexopti-client, lexopti-case, lexopti-clients, lexopti-cases"
)) {
element.innerHTML = `<p role="alert">LexOpti est momentanément indisponible. <a href="https://app.lexopti.com" target="_blank" rel="noopener">Ouvrir LexOpti</a></p>`;
}
}
// Une requête qui ne se termine jamais ne déclenche aucune erreur : abandon après 10 s.
const late = new Promise((resolve) => setTimeout(resolve, 10_000, null));
Promise.race([customElements.whenDefined("lexopti-client"), late]).then(
(defined) => defined || lexoptiUnavailable()
);
</script>
<script
type="module"
src="https://embed.lexopti.com/embed/v1.0.0.js"
integrity="sha384-2N9mNdBzYHj8ZSUxBaHxKXNPRwcwlKcJQ7PopEKhcDnoKBmAJ8RVKFcn4FXAOWTZ"
crossorigin="anonymous"
onerror="lexoptiUnavailable()"
></script>
  • onerror se déclenche dès que le navigateur refuse le fichier : empreinte différente, erreur réseau, 404, script bloqué par votre politique. Définissez sa fonction avant la balise, dans un script classique, exécuté pendant l’analyse de la page.
  • Sous une Content-Security-Policy sans 'unsafe-inline' ni 'unsafe-hashes', le navigateur ignore les gestionnaires en ligne comme onerror="…" : créez la balise depuis votre propre script et attachez-y l’écouteur (script.addEventListener("error", lexoptiUnavailable)), ou fiez-vous au seul délai.
  • customElements.whenDefined couvre ce qui ne déclenche aucune erreur, une requête qui ne se termine jamais ; tous les composants sont définis par le même script, en attendre un suffit.
  • Le message est le contenu propre de l’élément : si le script s’exécute finalement, l’élément est défini, son écran prend la place et sa racine fantôme fermée n’affiche rien de ce contenu.

Certains parcours exigent une fenêtre de premier niveau, celle de LexOpti : les navigateurs les refusent ou les restreignent dans un cadre tiers (cookies, WebAuthn, pages de paiement). Les composants ne les affichent jamais ; ils ouvrent LexOpti dans un nouvel onglet, par l’élément (seulement vers l’application LexOpti que l’iframe a annoncée) :

Parcours Dans le composant
La connexion, avec son second facteur Le message Ouvrir LexOpti ci-dessus
Les clés d’accès (passkeys), si le membre en utilise De même : WebAuthn exige une fenêtre de premier niveau
L’achat de crédits, l’abonnement, le changement d’offre ou de moyen de paiement La boîte de dialogue de quota ouvre la facturation de l’organisation dans LexOpti
La liaison de LexOpti à votre application (consentement OAuth) Votre propre page, avant tout composant (étape 1)
L’acceptation d’une invitation, les premiers pas d’une nouvelle organisation LexOpti, hors de tout composant
Les réglages de l’organisation Des liens vers LexOpti, dans un nouvel onglet

L’hôte embarqué ne sert même pas ces pages : seulement les écrans des composants, leur API et le point d’échange des jetons.

  • Chaque iframe a un titre dans la langue du composant (« Client LexOpti », « LexOpti client », « Dossier LexOpti », « LexOpti case ») ; le panneau et le plein écran sont des boîtes de dialogue portant le même nom (en ligne, le composant n’en est pas une), et leur bouton de fermeture se lit « Fermer » ou « Close ».
  • Ouvrir le panneau ou le plein écran place le focus dans l’écran ; le fermer (Échap, pressée dans l’écran ou sur le bouton de fermeture, le bouton de fermeture, le fond) rend le focus au contrôle de votre page qui l’avait, ou à l’écran quand le membre y était.
  • Tant qu’ils sont ouverts, votre page est inerte : son focus clavier et son défilement ne bougent pas derrière eux.
  • Le panneau ne glisse que si le visiteur n’a pas demandé à réduire les animations (prefers-reduced-motion).
  • Pendant le chargement, le squelette a la forme de l’écran et est annoncé comme un chargement aux technologies d’assistance ; ses erreurs sont annoncées comme des alertes.