Diagnostics

Tous les diagnostics que le compilateur peut émettre, au même endroit. Les erreurs font échouer typeflow check (code de sortie non nul) ; les avertissements non, mais ils méritent attention. Les codes sont stables — on peut les grepper et pointer dessus sans risque.

Chaque exemple ci-dessous est vivant (modifiez-le !) et vérifié au build : la génération de la doc compile chacun d'eux et échoue s'il cesse de reproduire son code.

Code	Sévérité	Signification
TF1001	erreur	Erreur lexicale
TF1002	erreur	Erreur de parsing
TF2001	erreur	Identifiant inconnu
TF2002	erreur	Propriété inconnue
TF2003	erreur	Accès non sûr à travers une valeur optionnelle
TF2004	erreur	Incompatibilité opérateur / type
TF2005	erreur	Filtre ou index sur un non-tableau
TF2006	erreur	Accès à une propriété ou cible de projection invalide
TF2007	erreur	Fonction inconnue
TF2008	erreur	Arguments de fonction incorrects
TF2009	erreur	Prédicat de filtre non booléen
TF2010	erreur	Type d’entrée non résolu
TF2011	erreur	Clé de tri invalide
TF2012	erreur	Accès à une propriété sur 'unknown'
TF2013	avertissement	'??' inutile (jamais nullish)
TF2014	erreur	Propriété dupliquée
TF2015	avertissement	Aucune déclaration 'input'
TF2016	erreur	Conflit de nom de fonction
TF2017	erreur	Type de retour de 'fn' incompatible
TF2018	erreur	Binding dupliqué
TF2367	avertissement	Comparaison sans recouvrement

TF1001 — Erreur lexicale erreur

La source contient du texte que le lexer ne peut pas transformer en tokens — le plus souvent une chaîne non terminée ou un caractère qui ne fait pas partie du langage.

Comment corriger — Fermer la chaîne (ou supprimer le caractère parasite). Le caret pointe sur l’offset exact.

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  greeting: "hello,
}

input user: { name: string } map { greeting: "hello, }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféréunknown

• 4:13errorTF1001Unterminated string literal.

TF1002 — Erreur de parsing erreur

Les tokens ne forment pas un mapping valide — un : manquant, un { non fermé, une virgule mal placée. Le parsing s’arrête à la première erreur structurelle : la corriger puis relancer la vérification, les erreurs suivantes peuvent disparaître.

Comment corriger — Le message indique ce que le parser attendait à cette position.

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  name user.name,
}

input user: { name: string } map { name user.name, }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféréunknown

• 4:8errorTF1002Expected ':'.

TF2001 — Identifiant inconnu erreur

Un nom nu ne correspond à rien dans la portée : ni le binding d’entrée, ni un champ d’élément de projection, ni un paramètre de fonction. Typeflow suggère le nom visible le plus proche.

Comment corriger — Vérifier l’orthographe par rapport à la déclaration input (ou à la projection englobante).

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  name: usr.name,
}

input user: { name: string } map { name: usr.name, }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: any }

• 4:9errorTF2001Cannot find name 'usr'. Did you mean 'user'?

TF2002 — Propriété inconnue erreur

La vérification phare : un segment de chemin n’existe pas sur le type depuis lequel il est lu. En code classique, cette faute de frappe serait un undefined silencieux en production — ici c’est une erreur à la compilation avec une suggestion « did you mean ».

Comment corriger — Corriger l’orthographe, ou mettre à jour le type d’entrée si les données possèdent réellement ce champ.

Mapping✖ 1Playground ↗

input user: { email: string, firstName: string }

map {
  mail: user.emial,
}

input user: { email: string, firstName: string } map { mail: user.emial, }

JSON d'entrée

{ "email": "ada@lovelace.dev", "firstName": "Ada" }

{ "email": "ada@lovelace.dev", "firstName": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ mail: any }

• 4:14errorTF2002Property 'emial' does not exist on type '{ email: string; firstName: string }'. Did you mean 'email'?

TF2003 — Accès non sûr à travers une valeur optionnelle erreur

Un chemin traverse avec un simple . un segment qui peut être undefined ou null (déclaré ?: ou nullable). La même règle protège les projections -> et les filtres/indexations [...] sur des cibles potentiellement nullish.

Comment corriger — Utiliser l’opérateur d’accès optionnel (?.), ou fournir d’abord une valeur par défaut avec ??. Une valeur par défaut ?? supprime aussi l’optionnalité du type de sortie inféré.

Mapping✖ 1Playground ↗

input user: { contact?: { email: string } }

map {
  email: user.contact.email,
}

input user: { contact?: { email: string } } map { email: user.contact.email, }

JSON d'entrée

{ "contact": { "email": "ada@lovelace.dev" } }

{ "contact": { "email": "ada@lovelace.dev" } }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ email: string }

• 4:23errorTF2003Object is possibly 'undefined'.
  indice: Use the optional access operator: '?.email', or provide a default with '??'.

TF2004 — Incompatibilité opérateur / type erreur

Un opérateur a reçu des opérandes qu’il n’accepte pas : + entre une chaîne et un nombre (Typeflow ne fait jamais de coercition), de l’arithmétique sur des non-nombres, !/&&/|| sur des non-booléens, une condition ? : non booléenne, des comparaisons d’ordre entre types mélangés.

Comment corriger — Convertir explicitement — string(user.age), number(raw) — pour que l’intention soit visible dans le mapping.

Mapping✖ 1Playground ↗

input user: { name: string, age: number }

map {
  label: user.name + user.age,
}

input user: { name: string, age: number } map { label: user.name + user.age, }

JSON d'entrée

{ "name": "Ada", "age": 36 }

{ "name": "Ada", "age": 36 }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ label: any }

• 4:10errorTF2004Operator '+' cannot be applied to types 'string' and 'number'.
  indice: Typeflow does not coerce types: '+' expects two strings or two numbers.

TF2005 — Filtre ou index sur un non-tableau erreur

L’opérateur [...] (filtrage avec un prédicat, ou indexation avec un nombre) a été appliqué à quelque chose qui n’est pas un tableau.

Comment corriger — Vérifier le chemin — le segment avant [ doit être un tableau du type d’entrée.

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  first: user.name[0],
}

input user: { name: string } map { first: user.name[0], }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ first: any }

• 4:10errorTF2005Filtering or indexing requires an array type, got 'string'.

TF2006 — Accès à une propriété ou cible de projection invalide erreur

Une propriété a été lue sur un scalaire (number, string, boolean), ou une projection -> a été appliquée à quelque chose qui n’est ni un objet ni un tableau d’objets.

Comment corriger — Suivre le type inféré du côté gauche — le message montre exactement sur quel type l’accès a été tenté.

Mapping✖ 1Playground ↗

input user: { age: number }

map {
  city: user.age.city,
}

input user: { age: number } map { city: user.age.city, }

JSON d'entrée

{ "age": 36 }

{ "age": 36 }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ city: any }

• 4:18errorTF2006Cannot access property 'city' on type 'number'.

TF2007 — Fonction inconnue erreur

Un appel nomme une fonction qui n’est ni une fonction native, ni une définition fn, ni une déclaration use, ni une fonction enregistrée via defineFunction. L’indication liste tout ce qui est disponible.

Comment corriger — Choisir dans la liste de l’indication, ou déclarer la fonction (fn, use ou defineFunction).

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  name: capitalizeWords(user.name),
}

input user: { name: string } map { name: capitalizeWords(user.name), }

JSON d'entrée

{ "name": "ada lovelace" }

{ "name": "ada lovelace" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: any }

• 4:9errorTF2007Unknown function 'capitalizeWords'.
  indice: Available functions: string, length, contains, matches, upper, lower, trim, pad, substring, split, replace, base64encode, base64decode, encodeUrl, decodeUrl, encodeUrlComponent, decodeUrlComponent, number, formatBase, floor, ceil, round, abs, power, sqrt, random, sum, max, min, average, boolean, not, exists, count, join, append, zip, sort, reverse, shuffle, distinct, keys, values, lookup, merge, spread, type, now, millis, fromMillis, toMillis.

TF2008 — Arguments de fonction incorrects erreur

Une fonction a été appelée avec un mauvais nombre d’arguments, ou avec un argument dont le type ne correspond pas au paramètre. L’indication rappelle la signature complète. S’applique aussi bien aux fonctions natives qu’à vos propres fonctions fn / use / defineFunction.

Comment corriger — Respecter la signature — convertir les arguments explicitement quand nécessaire (upper(string(user.age))).

Mapping✖ 1Playground ↗

input user: { age: number }

map {
  shout: upper(user.age),
}

input user: { age: number } map { shout: upper(user.age), }

JSON d'entrée

{ "age": 36 }

{ "age": 36 }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ shout: string }

• 4:16errorTF2008Argument of type 'number' is not assignable to parameter of type 'string'.
  indice: upper(value: string): string

TF2009 — Prédicat de filtre non booléen erreur

L’expression à l’intérieur d’un filtre [...] doit être un booléen. Les identifiants nus dans un filtre se résolvent sur l’élément : labels[active] fonctionne quand active est un champ booléen — mais labels[name] est une chaîne, pas un prédicat.

Comment corriger — Écrire une vraie condition : labels[name == "core"].

Mapping✖ 1Playground ↗

input user: { labels: { name: string, active: boolean }[] }

map {
  named: user.labels[name],
}

input user: { labels: { name: string, active: boolean }[] } map { named: user.labels[name], }

JSON d'entrée

{ "labels": [{ "name": "core", "active": true }] }

{ "labels": [{ "name": "core", "active": true }] }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ named: { name: string; active: boolean }[] }

• 4:22errorTF2009A filter predicate must be of type 'boolean', got 'string'.

TF2010 — Type d’entrée non résolu erreur

Une déclaration input x: T from "./module" n’a pas pu être résolue : aucun adaptateur de schéma n’est configuré, le module n’existe pas, ou il n’exporte pas ce type. (Le playground ne peut pas importer de fichiers — cet exemple montre le diagnostic lui-même ; dans un projet, l’adaptateur TypeScript résout le type via l’API du compilateur.)

Comment corriger — Vérifier le chemin du module et le nom du type exporté — ou utiliser un type structurel inline.

Mapping✖ 1Playground ↗

input user: ApiUser from "./user-types"

map {
  id: user.id,
}

input user: ApiUser from "./user-types" map { id: user.id, }

JSON d'entrée

{ "id": 1 }

{ "id": 1 }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ id: any }

• 1:1errorTF2010Cannot resolve type 'ApiUser' from './user-types': no schema adapter is configured.

TF2011 — Clé de tri invalide erreur

Une clé de tri ^(...) doit s’évaluer en number ou en string — les booléens, objets et tableaux n’ont pas d’ordre significatif. Les clés nullish sont acceptées : le runtime les trie en dernier.

Comment corriger — Trier sur un champ scalaire, ou en dériver un — ^(length(name)).

Mapping✖ 1Playground ↗

input user: { labels: { name: string, active: boolean }[] }

map {
  sorted: user.labels^(active).name,
}

input user: { labels: { name: string, active: boolean }[] } map { sorted: user.labels^(active).name, }

JSON d'entrée

{ "labels": [{ "name": "core", "active": true }] }

{ "labels": [{ "name": "core", "active": true }] }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ sorted: string[] }

• 4:24errorTF2011A sort key must be of type 'number' or 'string', got 'boolean'.

TF2012 — Accès à une propriété sur 'unknown' erreur

Une valeur typée unknown ne peut pas être déréférencée — contrairement à any, unknown signifie « je ne promets rien sur cette forme », et Typeflow vous y tient.

Comment corriger — Affiner le type dans la déclaration d’entrée, ou transmettre la valeur telle quelle.

Mapping✖ 1Playground ↗

input user: { data: unknown }

map {
  name: user.data.name,
}

input user: { data: unknown } map { name: user.data.name, }

JSON d'entrée

{ "data": { "name": "Ada" } }

{ "data": { "name": "Ada" } }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: any }

• 4:19errorTF2012Property 'name' does not exist on type 'unknown'.

TF2013 — '??' inutile (jamais nullish) avertissement

Le côté gauche de ?? ne peut jamais être null ou undefined, donc la valeur de repli est du code mort. Souvent un reliquat après qu’un type d’entrée a gagné un champ requis — le compilateur le signale pour que les mappings n’accumulent pas de scories.

Comment corriger — Supprimer le ?? default, ou rendre le champ d’entrée optionnel s’il peut réellement être absent.

Mapping✔Playground ↗

input user: { name: string }

map {
  name: user.name ?? "anonymous",
}

input user: { name: string } map { name: user.name ?? "anonymous", }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

{
  "name": "Ada"
}

type inféré{ name: string }

• 4:9warningTF2013The left side of '??' has type 'string', which is never null or undefined.

TF2014 — Propriété dupliquée erreur

La même clé apparaît deux fois dans le corps d’un objet. JSON garderait silencieusement la dernière — Typeflow refuse l’ambiguïté.

Comment corriger — Supprimer ou renommer l’une des deux.

Mapping✖ 1Playground ↗

input user: { name: string }

map {
  name: user.name,
  name: upper(user.name),
}

input user: { name: string } map { name: user.name, name: upper(user.name), }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: string }

• 5:3errorTF2014Duplicate property 'name'.

TF2015 — Aucune déclaration 'input' avertissement

Sans déclaration input, l’entrée est typée any : le mapping s’exécute quand même, mais les chemins ne peuvent pas être validés — on perd tout l’intérêt du langage.

Comment corriger — Lier l’entrée : input user: T from "./module", ou un type structurel inline.

Mapping✔Playground ↗

map {
  answer: 42,
}

map { answer: 42, }

JSON d'entrée

{}

{}

Sortie

{
  "answer": 42
}

type inféré{ answer: 42 }

• 1:5warningTF2015No 'input' declaration: the input is typed as 'any' and paths cannot be validated.
  indice: Declare one, e.g.: input user: User from "./types"

TF2016 — Conflit de nom de fonction erreur

Une définition fn, une déclaration use ou une fonction enregistrée porte le même nom qu’une fonction native ou qu’une autre fonction. Un nom, un sens — masquer les fonctions natives ferait signifier des choses différentes aux mappings selon le projet.

Comment corriger — Renommer votre fonction.

Mapping✖ 1Playground ↗

input user: { name: string }

fn upper(v: string): string = v

map {
  name: upper(user.name),
}

input user: { name: string } fn upper(v: string): string = v map { name: upper(user.name), }

JSON d'entrée

{ "name": "Ada" }

{ "name": "Ada" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: string }

• 3:4errorTF2016Function 'upper' conflicts with a built-in function.

TF2017 — Type de retour de 'fn' incompatible erreur

Un fn déclare un type de retour, mais son corps s’évalue en quelque chose qui n’est pas assignable à ce type. Le type déclaré est un contrat — le corps doit le satisfaire.

Comment corriger — Corriger le corps, ou corriger (ou supprimer) le type de retour déclaré — il est optionnel et inféré depuis le corps.

Mapping✖ 1Playground ↗

input user: { score: number }

fn label(n: number): string = n * 2

map {
  label: label(user.score),
}

input user: { score: number } fn label(n: number): string = n * 2 map { label: label(user.score), }

JSON d'entrée

{ "score": 21 }

{ "score": 21 }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ label: string }

• 3:22errorTF2017Function 'label' returns 'number', which is not assignable to the declared type 'string'.

TF2018 — Binding dupliqué erreur

Deux bindings let du même bloc objet partagent un nom. Un binding ne voit que les bindings déclarés avant lui : redéfinir un nom dans le même bloc est ambigu — Typeflow le refuse.

Comment corriger — Renommer l’un des bindings.

Mapping✖ 1Playground ↗

input user: { first: string, last: string }

map {
  let full = user.first + " " + user.last,
  let full = user.last,
  name: full,
}

input user: { first: string, last: string } map { let full = user.first + " " + user.last, let full = user.last, name: full, }

JSON d'entrée

{ "first": "Ada", "last": "Lovelace" }

{ "first": "Ada", "last": "Lovelace" }

Sortie

// Corrigez les erreurs du mapping pour voir la sortie.

type inféré{ name: string }

• 5:7errorTF2018Duplicate binding 'full'.

TF2367 — Comparaison sans recouvrement avertissement

Les deux côtés d’une comparaison ont des types qui ne peuvent jamais être égaux — un number comparé à une string, par exemple. La comparaison est légale mais toujours false, ce qui est presque toujours un bug : Typeflow ne fait jamais de coercition, donc age == "36" ne fait pas ce qu’il ferait en JavaScript. (Même numéro que le TS2367 de TypeScript, à dessein.)

Comment corriger — Comparer avec le bon type — user.age == 36 — ou convertir explicitement avec string() / number().

Mapping✔Playground ↗

input user: { age: number }

map {
  isAdult: user.age == "18",
}

input user: { age: number } map { isAdult: user.age == "18", }

JSON d'entrée

{ "age": 36 }

{ "age": 36 }

Sortie

{
  "isAdult": false
}

type inféré{ isAdult: boolean }

• 4:12warningTF2367This comparison appears to be unintentional because the types 'number' and '"18"' have no overlap.