Référence des traductions

Les traductions sont fortement typées. Vous pouvez fournir des surcharges soit via le provider, soit directement dans la configuration de table sous translations.keys.

Important : quand vous utilisez le catalogue form (create/edit via getFormConfig), le formulaire utilise la même fonction de traduction t() que la table, c'est-à-dire le même objet DataTableTranslations passé au provider. Vous devez inclure les clés form et value dans cet objet pour que les labels de champs, placeholders (y compris le champ value-type) et boutons de formulaire se résolvent correctement. Sinon, vous verrez des clés brutes comme value.string_placeholder dans l'UI.

Structure du type

type DataTableTranslations = {
  actions: { delete: string; edit: string; copy: string; export: string; save: string; cancel: string; confirm: string; title: string; view: string };
  bulk: { close_menu: string; confirm_copy_description: string; confirm_delete_description: string; confirm_title: string };
  calculations: { none: string; count: string; percent: string; more: string; count_all: string; count_values: string; count_unique: string; count_empty: string; count_not_empty: string; count_true: string; count_false: string; percent_empty: string; percent_not_empty: string; percent_true: string; percent_false: string; sum: string; average: string; median: string; min: string; max: string; range: string; calculate: string };
  columns: { title: string; hide: string; show: string; visible: string; hidden: string; drag: string; resetOrder: string; toggleVisibility: string; hideAll: string; showAll: string; edit_property: string; filter: string; hide_in_view: string; reorder: string; resize?: string; sort_ascending: string; sort_descending: string };
  menu: { /* ... */ density?: string; footer_calculations: string; footer_calculations_on: string; footer_calculations_off: string };
  pagination: { first: string; last: string; next: string; previous: string; of: string; page: string; rowsPerPage: string; showing: string; selectedCount: string };
  selection: { rows: string };
  // ... see full type in types/translations.ts
}

Surcharge inline (config)

translations: {
  namespace: 'common',
  keys: {
    'columns.title': 'Columns',
    'actions.title': 'Actions',
  },
}

Via provider

Vous pouvez fournir un objet DataTableTranslations complet au provider pour une localisation cohérente sur toutes les tables.

Où les traductions s'appliquent

• Densité du tableau : menu.density définit le titre du menu, l’infobulle et le libellé accessible de son icône. Les tailles restent XS, S, M, L, XL et 2XL dans toutes les langues. La clé est optionnelle ; React utilise « Table density » par défaut. Vue inclut les traductions anglaise et française.

• Infobulles des icônes : densité, vues sauvegardées, modes d’affichage, actions, et contrôles de colonnes utilisent les mêmes libellés localisés au survol et au focus clavier. Fournissez views.add_view et views.saveChangesTooltip pour les icônes d’ajout et d’enregistrement de vue. Les actions personnalisées acceptent tooltip ; les actions à icône seule utilisent sinon leur libellé. Évitez un title natif en doublon.

• Réglages de la vue et Données : views.settings libelle le bouton icône des réglages (par défaut « Réglages de la vue ») ; views.viewActions libelle le chevron « Actions de la vue » des onglets et views.filterViews libelle le filtre par nom affiché au-delà de sept vues dans le menu du déclencheur nommé. menu.data libelle le bouton Données et son menu, qui regroupe Exporter, Connecter, Partager et, en mode compact, les actions de la barre d'outils de l'application ; destinations.connect libelle la ligne et l'écran Connecter (par défaut « Connecter »).

• Planification : schedule.<clé> remplace, clé par clé, les libellés anglais et français intégrés de l'écran de planification Connecter — par exemple schedule.frequency, schedule.manual, schedule.auto, schedule.hourly, schedule.daily, schedule.weekly, schedule.monthly, schedule.lastDay, schedule.timeZone, schedule.next (avec {date} et {zone}), schedule.save, schedule.cancel et schedule.runNow. Voir Planifier une destination de connexion.

• Écrans de connecteur : connector.<clé> remplace, clé par clé, les libellés anglais et français intégrés des écrans de connecteur. Écran : target, child, chooseTarget, use, loading, loadingFields, noTargets, columns, columnsVisible, columnsAll, mapping, newField, dontSend, sending, keyField, mode, upsert, replace, upsertHint, replaceHint, scope, scopeView, scopeSelection, send, sendAgain, done. Résultat : created, createdOne, updated, updatedOne, skipped, skippedOne, failed, failedOne, nothingSent, warnings, warningsOne, truncated, failureRow, failureRows (les clés …One sont les formes au singulier ; les compteurs utilisent {count}, failureRow utilise {id} et {message}, failureRows utilise {count} et {message}). Vérifications : issueMissingTarget, issueMissingChild, issueNoColumns, issueDuplicateField, issueUnknownField, issueMissingKey, issueUnknownKey, issueInvalidMode (avec {field} ou {child}). Erreurs : error_aborted, error_api_disabled, error_forbidden, error_invalid_credentials, error_invalid_mapping, error_invalid_request, error_invalid_target, error_not_found, error_not_shared, error_not_shared_unknown, error_provider_unavailable, error_rate_limited, error_unauthorized, error_unknown (error_not_shared utilise {email}). newField utilise {name}, et columnsVisible, columnsAll et scopeSelection utilisent {count}. Synchronisation (Synchroniser depuis l'écran du connecteur) : direction, directionPush, directionPull, directionTwoWay (avec {target}), directionPushShort, directionPullShort, directionTwoWayShort (le résumé de planification), mappingPull, mappingTwoWay, dontImport, dontSync, sample (avec {value}), invalidCount, invalidOne, conflictRule, conflictTableWins, conflictTargetWins, conflictLatestWins, conflictTableWinsHint, conflictTargetWinsHint, conflictLatestWinsHint, deletePolicy, deleteFlag, deleteIgnore, deletePropagate, deleteFlagHint, deleteIgnoreHint, deletePropagateHint, deleteConfirm, confirmDeletesFirst, previewFirst, previewChanges, previewAgain, previewing, syncNow, importNow, syncing, inTarget (avec {target}), inTable, thisTable, toCreate, toUpdate, toDelete, nothingToChange, unchanged, flagged, flaggedOne, duplicates, duplicatesOne, conflicts, moreConflicts, wins (avec {side}), emptyValue, deleted, deletedOne, nothingChanged, syncStopped (avec {message}), issueNoFields, issueInvalidDirection, issueInvalidConflictRule, ainsi que importFrom (avec {name}) et importFromHint pour la source de Données › Importer. Règles de conflit (Règles de conflit définies par votre application) : appRules, appRulesLocked, ruleOwnedTable, ruleOwnedTarget, ruleMerge, ruleManual, ruleTableWins, ruleTargetWins, ruleLatestWins (les phrases de règle utilisent {column}, et ruleOwnedTarget et ruleTargetWins aussi {target}), les issues de la prévisualisation ownedBy (avec {side}), resolutionMerged, resolutionManual, resolutionCustom, resolutionSkipped, resultValue, overridden, moreOverridden, pendingNote, pendingNoteOne (avec {count}), et les conflits à résoudre conflictsToResolve (avec {count}), conflictsHint, keepTable, keepTarget (avec {target}), keepAllTable, keepAllTarget (avec {target}), noConflicts, resolvingConflicts, backToSettings, valueYes, valueNo. Vérification de la destination (Vérification et préparation de la destination) : targetCheck, checkingTarget (avec {target}), schemaBlocking, schemaFixable, schemaWarning, schemaBlocked (avec {reason}), les lignes de problème schemaIssue_missing_field, schemaIssue_deleted_field, schemaIssue_renamed_field, schemaIssue_incompatible_type, schemaIssue_invalid_values, schemaIssue_coercible_type, schemaIssue_unsupported_type, schemaIssue_read_only_field, schemaIssue_missing_options, schemaIssue_missing_status_options, schemaIssue_missing_key, schemaIssue_key_wrong_type, schemaIssue_duplicate_mapping, schemaIssue_title_unmapped, schemaIssue_field_missing (avec {column}, {field}, {target}, {actual}, {expected}, {from}, {to}, {options} ou {count}), updateMapping, prepareNotion, prepareSheet, prepareTarget (avec {target}), prepareIntro, prepareConfirm, preparing, prepared, preparedOne, preparedNothing (avec {count} et {target}), cancel, fixCreateField, fixCreateKey (avec {field} et {type}), fixAddOptions (avec {count}, {field} et {options}), providerNotion, providerSheets, les choix désactivés optionReadOnly, optionUnsupported, optionIncompatible (avec {field} et {type}) et optionUsed (avec {field} et {column}), pageTitle, pageTitleField (avec {field}), refreshTargets, createTarget, createTargetTitle (avec {target}), createParent, createName, createSubmit, creatingTarget, createNameRequired, et les noms de types type_<type> (comme type_rich_text ou type_formula).

• Import : import.<clé> remplace, clé par clé, les libellés anglais et français intégrés de l'écran d'import ; import.title nomme aussi l'entrée du menu Données. Source : title, source, sourceCsv, sourceCsvHint, chooseFile, dropHint, pasteLabel, usePasted, reading, fileError, emptyFile, sourceError, authError. Correspondance : mapping, ignore, delimiter, delimiterAuto (avec {delimiter}), delimiterComma, delimiterSemicolon, delimiterTab, delimiterPipe, headers, keyColumn, keyNone, keyHint, sample (avec {value}), noSample, invalidCount, invalidOne, preview, previewCaption, rowsFound, rowsFoundOne, yes, no. Vérification : review, back, cancel, creates, createsOne, updates, updatesOne, errorRows, errorRowsOne, skipErrors, errorsBlock, nothingToImport, rowError (avec {row}, {column} et {message}). Import et résultat : import, importing (avec {done} et {total}), stop, done, another, created, createdOne, updated, updatedOne, failed, failedOne, nothingImported, stopped, failureRow (avec {row} et {message}). Types de colonne des badges : type_text, type_number, type_date, type_boolean, type_select, type_multi, type_url, type_email, type_json. Erreurs de cellule : error_required, error_invalid_number, error_invalid_date, error_invalid_boolean, error_unknown_option, error_invalid_url, error_invalid_email, error_invalid_json, error_duplicate_key, error_unknown. Les clés …One sont les formes au singulier, et les compteurs utilisent {count}.

• Vue Formulaire : des clés plates form.<clé>, comme "form.submit": "Valider", remplacent, clé par clé, les libellés anglais et français intégrés de la vue Formulaire, en React comme en Vue. Elles sont distinctes des clés form du formulaire catalogue ci-dessous. Formulaire : submit, submitting, success, successTitle, another, required, choose, pickDate, clearDate, closed, noQuestions, submitError. Erreurs : errorRequired, errorNumber, errorDate, errorUrl, errorOption, errorSummary (avec {count} sous forme plurielle). Réglages : settings, settingsTitle, title, description, questions, ask, moveUp, moveDown, editQuestion, hiddenValue (avec {label}), label, help, placeholder, requiredToggle, hidden, hiddenHint, none, excluded (avec {columns}), afterSubmit, submitLabel, successMessage, allowAnother, redirectUrl, redirectHint, reset. Partage : share, publish, publishHint, publicLink, copy, copied, open, acceptResponses, republish, republishHint, saveFirst, shareError, loading, close. Présentation et étapes : layout, layoutPage, layoutSteps, review, next, back, skip, stepProgress (avec {current} et {total}), reviewTitle, reviewChange (avec {label}), noAnswer, yes, no. Sections : addSection, section, sectionTitle, sectionDescription, untitledSection, editSection, removeSection (ces deux avec {label}). Éditeur de règles : conditions, addRule, ruleAction, actionShow, actionHide, actionRequire, ruleJoin, joinAnd, joinOr, ruleField, ruleOperator, ruleValue, ruleFrom, ruleTo, ruleDays, chooseQuestion, addCondition, addGroup, ruleGroup, removeCondition, removeGroup, removeRule, editConditions, conditionsTitle (avec {label}), conditionsDescription, noConditions, conditionsProblem, done, joinAll, joinAny, ruleDaysUnit. Problèmes de règles : issueMissingField, issueUnknownField, issueOperator, issueMissingValue, issueUnknownOption, issueEmptyGroup, issueCycle, issueLaterQuestion, issueSelfReference, issueTarget. Résumés de règles : thenShow, thenHide, thenRequire (avec {condition}), thenSet (avec {value} et {condition}), ruleAnd, ruleOr, ruleCustom, et les formulations de comparaison opIs, opIsNot, opContains, opNotContains, opStartsWith, opEq, opNeq, opLt, opLte, opGt, opGte, opBetween, opOn, opBefore, opAfter, opInLast, opInNext, opIsAnyOf, opIsNoneOf, opContainsAny, opContainsAll, opContainsNone, opIsChecked, opIsUnchecked, opIsEmpty, opIsNotEmpty (avec {field} et {value}, ou {from} et {to} pour opBetween). Libellés de comparaison : les libellés courts du menu des comparaisons, à côté de ces formulations de résumé, comme « est », « avant le » ou « dans les derniers » : cmpIs, cmpIsNot, cmpContains, cmpNotContains, cmpStartsWith, cmpEq, cmpNeq, cmpLt, cmpLte, cmpGt, cmpGte, cmpBetween, cmpOn, cmpBefore, cmpAfter, cmpInLast, cmpInNext, cmpIsAnyOf, cmpIsNoneOf, cmpContainsAny, cmpContainsAll, cmpContainsNone, cmpIsChecked, cmpIsUnchecked, cmpIsEmpty, cmpIsNotEmpty. Le nom du mode est views.display.form en React et display.form en Vue.

• Vue Graphique : des clés plates chart.<clé>, comme "chart.showTable": "Vue tableau", remplacent, clé par clé, les libellés anglais et français intégrés de la vue Graphique, en React comme en Vue. Réglages : chartType, typeBar, typeHorizontalBar, typeLine, typeDonut, typeNumber, xColumn, bucket, day, week, month, quarter, year, metric, metricCount, metricSum, metricAvg, metricMin, metricMax, metricCountDistinct, metricColumn, seriesColumn, none, stacked, sort, sortAuto, sortKeyAsc, sortKeyDesc, sortValueAsc, sortValueDesc, sortManual, cumulative, hideEmpty, topN, topAll, top, showDataLabels, showLegend, colors, colorsOptions, colorsPalette, weekStartsOn, monday, sunday, saturday, on, off, reset (top avec {count}). Graphique : showTable, showChart, other, noValue, checked, unchecked, weekOf, quarterLabel, count, sumOf, avgOf, minOf, maxOf, countDistinctOf, total, group, chartOf, showRecords (weekOf avec {date}, quarterLabel avec {quarter} et {year}, les clés …Of avec {column}, chartOf avec {metric} et {column}, showRecords avec {group}). Messages : noColumn, empty, loading, truncated, filterHint, filterUnavailable. Le nom du mode est views.display.chart en React et display.chart en Vue.

• Vue Fil : des clés plates feed.<clé>, comme "feed.loadMore": "Publications plus anciennes", remplacent, clé par clé, les libellés anglais et français intégrés de la vue Fil, en React comme en Vue. Fil : showMore, showLess, loadMore, loading, loadingMore, error, retry, end, untitled, noValue, yes, no, moreImages (avec {count}), by, media (avec {title}). Réglages : titleColumn, authorColumn, dateColumn, dateDisplay, relative, absolute, bodyColumn, mediaColumn, properties, showPropertyLabels, bodyLines, lines (avec {count}), noLimit, density, comfortable, compact, pageSize, infiniteScroll, on, off, none.

• Vue Arborescence : des clés plates filetree.<clé>, comme "filetree.newFolder": "Nouvel album", remplacent, clé par clé, les libellés anglais et français intégrés de la vue Arborescence, en React comme en Vue. Affichage : root, name, size, modified, type, path, newFolder, newFolderName, folderName, expandAll, collapseAll, details, hideDetails, info, open, preview, rename, moveTo, moveHere, delete, cancel, create, back, actions, expand, collapse, close, resizeDetails, noSelection, contents, shortcuts, sortBy (avec {name}). Sélection : selectRow, selectAll, selected (avec {count}), clearSelection. Arborescence : unfiled, showMore (avec {count}), showMoreUnknown, emptyFolder, empty, noMatches, loading, folder, file, oneFolder, oneFile, loaded, folders, files, items (ces quatre avec {count}), justNow, truncated, expandedFirst, uploading (ces trois avec {count}). Déplacements et suppressions : moved, moveItems (les deux avec {count} et {path}), movedOne, moveItem (les deux avec {name} et {path}), moveFailed (avec {count}), undo, undone, cutReady (avec {count}), created, renamed (les deux avec {name}), deleteTitle (avec {count}), deleteOneTitle (avec {name}), deleteDescription, deleted (avec {count}), intoSelf, intoDescendant, noPermission, notAFolder, virtualFolder, alreadyThere, moveDialogTitle (avec {count}), moveOneDialogTitle (avec {name}), searchFolders. Réglages : settingsParent, settingsKind, settingsName, settingsSize, settingsUpdated, settingsColumns, settingsDetails, settingsFoldersFirst, settingsDepth, columnsBoth, columnsSize, columnsUpdated, columnsNone, depth0, depth1, depth2, none, on, off. Le nom du mode est views.display.filetree en React et display.filetree en Vue.

• Vue Carte : des clés plates map.<clé>, comme "map.searchArea": "Chercher ici", remplacent, clé par clé, les libellés anglais et français intégrés de la vue Carte, en React comme en Vue. Carte : loading, map, noLocationColumn, withoutLocation (avec {count}), withoutLocationOne, searchArea, searching, fit, zoomIn, zoomOut, open, close, cluster (avec {count}), marker (avec {title}). Liste : list, inView (avec {count}), showList, hideList, emptyList. Messages : truncated (avec {count}), clientFiltered, noStyle, unavailable. Réglages : locationColumn, titleColumn, colorColumn, none, popupColumns, showPopupLabels, clusterSetting, style, initialView, initialFit, initialSaved, searchOnMove, on, off. Le nom du mode est views.display.map en React et display.map en Vue.

• Colonnes de lieu : des clés plates location.<clé>, comme "location.search": "Trouver une adresse", remplacent, clé par clé, les libellés anglais et français intégrés des cellules, éditeurs et filtres de lieu, en React comme en Vue. Éditeur : location, pin, label, address, latitude, longitude, search, searching, noResults, searchFailed, suggestions, clear, done, cancel, edit, invalidCoordinates, coordinatesHint, noLocation. Filtres : withinDistance, withinBounds, distance, west, south, east, north, withinKm (avec {km} et {point}), inArea (avec {south}, {west}, {north} et {east}). Les noms des opérateurs sont filters.operators.within_distance et filters.operators.within_bounds.

• Tableau de bord : des clés dashboard.<clé> dans la prop translations du tableau de bord, comme "dashboard.refresh": "Recharger", remplacent, clé par clé, les libellés anglais et français intégrés du tableau de bord, en React comme en Vue. En-tête et états : dashboard, edit, done, saving, saved, saveError, loadError (avec {error}), loading, notFound, refresh, empty, emptyEditable. Ajout de widget : addWidget, addWidgetTitle, widgetType, typeView, typeKpi, typeNote, table, view, defaultView, metric, metricCount, metricSum, metricAvg, metricMin, metricMax, metricColumn, widgetTitle, noteText, add, cancel. Widgets : widgetMenu, dragHandle (avec {title}), moveLeft, moveRight, moveUp, moveDown, wider, narrower, taller, shorter, remove, openFullView, widgetLoading, widgetError (avec {error}), retry, missingTable, missingView, emptyNote, kpiCount, moved, resized (avec {title}). Filtres : filters, from, to, any, clear, appliesTo (avec {targets}), addFilter, addFilterTitle, filterType, filterDateRange, filterSelect, filterName, filterColumn (avec {table}), notApplied, removeFilter (avec {name}), noFilterColumns, anyDate, fromDate, untilDate (avec {date}), dateRange (avec {start} et {end}).

• Filtres (avancés) : les libellés d'opérateurs (Contains, Equals, Starts with, etc.) utilisent les clés filters.operators.*. Les options du menu et la valeur sélectionnée affichée lorsque le select est fermé sont traduites, donc l'opérateur courant apparaît toujours dans la locale active (par ex. “Contient” au lieu de “contains”).

• Pagination : tous les libellés sont traduits : “Rows per page” (pagination.rowsPerPage), le texte “Page X of Y” (pagination.showing, avec {page} et {total}), et les labels des boutons first/previous/next/last (pagination.first, pagination.previous, etc.). La pagination par défaut et la pagination de style boutons (SafePagination) utilisent ces clés.

• Calculs de footer : les libellés du menu de calcul et les résultats utilisent les clés calculations.*. Le toggle du menu options utilise menu.footer_calculations, menu.footer_calculations_on et menu.footer_calculations_off.

Traductions de formulaire (catalogue form)

Quand vous utilisez getFormConfig et le formulaire create/edit intégré (catalogue form), le formulaire résout tous les labels, placeholders et textes de boutons depuis le même objet DataTableTranslations passé au provider. Ajoutez une section form et value dans cet objet.

• form – Labels de champs (utilisez labelKey dans votre form config, par ex. form.name), boutons de formulaire (cancel, submit, create, update) et messages succès/erreur. Le catalogue form utilise aussi createForm.title et createForm.description pour l'en-tête de dialog/drawer. Pour les champs select, utilisez form.valueType_options.boolean etc. si vous utilisez optionKeys.

• value – Utilisé par le champ value-type : value.string_placeholder, value.json_placeholder, value.number_placeholder, et pour le switch booléen value.enabled / value.disabled.

Dans votre form config, définissez labelKey (et éventuellement placeholderKey, optionKeys) sur chaque champ pour que le form builder remplace labels/options par t(labelKey).

Exemple d'objet (form + value)

Fusionnez ceci dans l'objet DataTableTranslations que vous passez à la table (par ex. à côté de actions, columns, filters, etc.) :

const myTableTranslations = {
  // ... actions, columns, filters, etc. ...

  form: {
    cancel: "Cancel",
    create: "Create",
    createError: "Failed to create",
    createForm: {
      description: "Add a new item.",
      title: "Create item",
    },
    created: "Created successfully",
    name: "Name",
    slug: "Slug",
    category: "Category",
    description: "Description",
    enabled: "Enabled",
    valueType: "Value type",
    value: "Value",
    submit: "Save",
    update: "Update",
    updateError: "Failed to update",
    updated: "Updated successfully",
    valueType_options: {
      boolean: "Boolean",
      number: "Number",
      string: "String",
      json: "JSON",
    },
  },
  value: {
    string_placeholder: "Default string value",
    json_placeholder: "{}",
    number_placeholder: "0",
    enabled: "Enabled",
    disabled: "Disabled",
  },
};

Exemple de form config avec labelKey et optionKeys pour utiliser ces clés :

defineFormConfig({
  id: "my-entity",
  defaultValues: { name: "", slug: "", valueType: "string", value: null, enabled: false },
  fields: [
    { name: "name", type: "text", label: "Name", labelKey: "form.name", required: true },
    { name: "slug", type: "text", label: "Slug", labelKey: "form.slug", required: true },
    {
      name: "valueType",
      type: "select",
      label: "Value type",
      labelKey: "form.valueType",
      optionKeys: [
        "form.valueType_options.boolean",
        "form.valueType_options.number",
        "form.valueType_options.string",
        "form.valueType_options.json",
      ],
      options: [
        { label: "boolean", value: "boolean" },
        { label: "number", value: "number" },
        { label: "string", value: "string" },
        { label: "json", value: "json" },
      ],
    },
    {
      name: "value",
      type: "value-type",
      label: "Value",
      labelKey: "form.value",
      valueTypeField: "valueType",
      supportedTypes: ["boolean", "json", "number", "string"],
    },
  ],
  schema: mySchema,
  translations: {
    namespace: "my.namespace",
    keys: {
      cancel: "form.cancel",
      submit: "form.submit",
      create: "form.create",
      update: "form.update",
      created: "form.created",
      updated: "form.updated",
      createError: "form.createError",
      updateError: "form.updateError",
      "createForm.title": "form.createForm.title",
      "createForm.description": "form.createForm.description",
    },
  },
});

Voir aussi :

• DataTable

• Columns

• Provider & Setup (getFormConfig)

Toutes les clés (dot-path)

Utilisez les clés suivantes pour construire votre objet de traduction. Toutes les valeurs sont des strings.

actions

Utilisé par les actions de ligne, l'entrée Exporter du menu Données, et le menu des actions de masse (onglets Edit, Copy, Export, Delete et boutons de dialogue).

bulk

Chaînes utilisées par le panneau des actions de masse (affiché quand une ou plusieurs lignes sont sélectionnées). Supporte {action}, {count} et le pluriel ICU : {count, plural, one {item} other {items}}.

columns

common

filters

filters.operators

filters.types

filters.date_shortcuts

filters.advanced

filters.faceted

filters.add_menu

filters.presets

pagination

Utilisé par la pagination par défaut et la pagination de style boutons (par ex. “Lignes par page”, “Page 1 of 2”). pagination.showing est utilisé pour le texte “Page X of Y” et supporte {page} et {total}. Valeur anglaise par défaut : "Page {page} of {total}" (exemple français : "Page {page} sur {total}").

search

selection

Utilisé pour l'en-tête de la colonne de sélection et le compteur du menu des actions de masse (par ex. “3 rows selected”). Supporte {count} et l'ICU plural.

sorting

views

state

url_state

demo

table

calculations

menu

form (catalogue form)

Incluez ces clés lors de l'utilisation des formulaires create/edit pour que labels, placeholders et boutons se résolvent. Utilisez labelKey / optionKeys dans votre form config pour pointer vers ces clés.

value (value-type field)

Utilisé par le champ value-type du formulaire pour les placeholders et labels booléens.

root

Les deux éditions utilisent add_an_item pour le bouton de création de la barre d’outils (« Add item » en anglais, « Ajouter » en français). Vue lisait auparavant sa propre clé create pour ce bouton ; si vous aviez traduit create pour ce bouton, déplacez cette traduction vers add_an_item. La clé de titre du formulaire form.create du formulaire catalogue est indépendante et inchangée.

Contrôles Vue : filtres, menus et formulaires

Vue fournit des valeurs par défaut anglaises et françaises. Les filtres avancés acceptent les mêmes clés filters.* que React, notamment filters.add, filters.apply, filters.column, filters.value_to, filters.operators.between et filters.advanced.disable_filter.

Les champs et collections réutilisables Vue héritent des traductions de table pour chargement, nouvelle tentative, création d'option, édition d'élément et dialogues. Sans fournisseur de table, les contrôles autonomes conservent leurs valeurs anglaises. Les clés des champs et sections continuent d'utiliser la configuration du formulaire ; traduire les contrôles ne modifie pas les valeurs métier ou les erreurs serveur.

Vues sauvegardées, Options, menus de ligne, confirmations et messages d'état utilisent la locale de table. Un dictionnaire personnalisé surcharge les valeurs par défaut sans modifier navigation clavier et focus. Les rendus React et les composants/VNodes Vue restent dans leur runtime respectif.

Traductions de l'état vide

React utilise table.no_results pour le titre filtré, table.no_results_description pour sa description, state.noData pour un jeu de données vide et filters.clear pour le bouton et son nom accessible. Fournissez les quatre lors d'une surcharge du provider pour éviter de conserver des textes anglais. pagination.autoPageSize nomme l'option Automatique.

Vue utilise noResults, noResultsDescription, noDataAvailable et clearFilters, avec des valeurs anglaises et françaises. Les mêmes clés s'appliquent à Table, Kanban et Gallery. Les valeurs explicites de table.emptyState.title et description ont priorité sur les traductions contextuelles.

Traductions des favoris

React expose views.favorite, views.setFavorite, views.removeFavorite et views.favoriteError. Vue expose favoriteView, setFavoriteView, removeFavoriteView et favoriteViewError, avec des valeurs anglaises/françaises. L’infobulle et le nom accessible de l’étoile utilisent la même traduction ; aria-pressed indique si la vue active est favorite.

Traductions des onglets de vues

React utilise views.tabs (« Views ») comme nom accessible de la liste d’onglets, views.more (« More views ») pour le nom et l’infobulle du bouton de débordement …, views.newView (« New view ») pour l’onglet « + » qui ouvre le formulaire de sauvegarde, et views.dialog.save.layout (« Layout ») pour le choix de mise en page dans ce formulaire. Vue utilise viewTabs, moreViews, newView et viewLayout pour ces quatre libellés, avec des valeurs anglaises (« Views », « More views », « New view », « Layout ») et françaises (« Vues », « Plus de vues », « Nouvelle vue », « Mise en page »). Depuis v3.9.0, le débordement est un bouton à icône : un hôte qui traduisait views.more (Vue moreViews) par « Plus » le traduit par « Plus de vues ».

L’ordre des vues ajoute en React views.moveLeft, views.moveRight, views.moveUp, views.moveDown, views.moved (avec {name}, {position} et {count}, annoncé après un déplacement) et views.orderError ; React revient à l’anglais quand vos traductions ne les ont pas. Vue a moveViewLeft, moveViewRight, moveViewUp, moveViewDown, viewMoved et viewOrderError, avec des valeurs anglaises et françaises.

Traductions des facettes, dossiers et tags

Le panneau de facettes, les dossiers des autres vues et les colonnes de tags ont des libellés anglais et français intégrés dans les deux éditions, choisis selon la langue de la table. Remplacez-les avec des clés plates facets.<clé>, filetree.<clé> (la fenêtre et le sélecteur de dossiers ajoutent rootFolder, parentFolder, inFolder, noFolders et createFailed) et tags.<clé> dans les traductions de la table.

Exemples de documentation localisés

Les aperçus intégrés reprennent la langue de la documentation. Les recettes complètes acceptent ces propriétés facultatives de présentation. Copiez ce type à côté de la recette. Omettez les propriétés pour garder l’interface anglaise par défaut, ou fournissez locale et le dictionnaire de traduction du framework. Les libellés métier des configurations et des formulaires restent à traduire dans votre application.

import type { DataTableTranslations } from "@/components/ui/yayaw-table/types/translations";

/** Optional host presentation; omit to use the registry defaults. */
export interface ExamplePresentation {
  locale?: string;
  title?: string;
  translations?: DataTableTranslations;
}

import type { DataTableTranslations } from "@/components/ui/yayaw-table-vue/types";

/** Optional host presentation; omit to use the registry defaults. */
export interface ExamplePresentation {
  locale?: string;
  title?: string;
  translations?: DataTableTranslations;
}