@evotecit/canopyx 0.3.2 → 0.3.4

package/JavaScript/flow.d.ts

@@ -0,0 +1,232 @@
+// Flows (docs/flow.md): guided forms with steps, typed fields, conditions as data, validation, a review page and one
+// proposal to the host. The flow entry point (@evotecit/canopyx/flow) and the grid entry points create them.
+import type { CanopyPlugin } from "./plugins.js";
+
+/** A value a field holds: text, a number, a boolean, a list of values, or nothing. Secrets never have one. */
+export type FlowValue = string | number | boolean | null | readonly (string | number | boolean)[];
+
+/** The field types: the shared grid editors, the types flows add, and custom editors. */
+export type FlowFieldType = "text" | "number" | "date" | "datetime" | "time" | "select" | "toggle" | "lookup" | "choice" | "multiChoice"
+  | "textarea" | "list" | "secret" | "duration" | "custom";
+
+/** A condition operator, from the filter builder's grammar. */
+export type FlowOperator = "eq" | "ne" | "gt" | "ge" | "lt" | "le" | "contains" | "notContains" | "startsWith" | "endsWith" | "matches" | "notMatches"
+  | "in" | "notIn" | "between" | "isNull" | "isNotNull";
+
+/** A condition as data: groups of predicates joined by and, or and none. At most eight levels, 64 groups and 64 predicates. */
+export interface FlowCondition {
+  operator: "and" | "or" | "none";
+  filters?: readonly { field: string; operator: FlowOperator; values?: readonly (string | number | boolean)[] }[];
+  groups?: readonly FlowCondition[];
+}
+
+/** A choice: a value, and how readers see it. */
+export interface FlowOption {
+  value: string | number | boolean;
+  label?: string;
+  description?: string;
+  badge?: string;
+  /** Shown beside a choice that cannot be picked. */
+  disabledReason?: string;
+  /** Multiple choice: the heading the option sits under. */
+  group?: string;
+}
+
+/** A field's checks: lengths and patterns for text, ranges for numbers, moments and durations, counts and item rules for lists. */
+export interface FlowValidation {
+  min?: number | string;
+  max?: number | string;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  message?: string;
+  minItems?: number;
+  maxItems?: number;
+  item?: "email" | "host" | "ip" | "cidr" | "url";
+  itemPattern?: string;
+}
+
+/** A field of a flow step. */
+export interface FlowField {
+  id: string;
+  type: FlowFieldType;
+  label: string;
+  help?: string;
+  placeholder?: string;
+  required?: boolean;
+  readOnly?: boolean;
+  default?: FlowValue;
+  when?: FlowCondition;
+  width?: "full" | "half";
+  parameter?: string;
+  /** The setting it writes, as dot-separated names; the host prepares parent objects before applying the JSON patch. */
+  path?: string;
+  sensitive?: boolean;
+  validation?: FlowValidation;
+  options?: readonly FlowOption[];
+  /** Choice fields: cards (default up to five options) or a list. */
+  display?: "cards" | "list";
+  onText?: string;
+  offText?: string;
+  rows?: number;
+  step?: number;
+  /** Secrets: a blank answer keeps the stored value. */
+  keepWhenBlank?: boolean;
+  /** Secrets: false hides the reveal button. */
+  reveal?: boolean;
+  units?: readonly ("seconds" | "minutes" | "hours" | "days")[];
+  /** Custom fields: the registered editor's name. */
+  editor?: string;
+}
+
+/** A section of a step: a heading over some of its fields. */
+export interface FlowSection { id: string; label: string; description?: string; fields: readonly FlowField[]; when?: FlowCondition }
+
+/** A step: a form, a page of text, or the review page (which comes last). */
+export interface FlowStep {
+  id: string;
+  title?: string;
+  description?: string;
+  type?: "form" | "info" | "review";
+  fields?: readonly FlowField[];
+  sections?: readonly FlowSection[];
+  when?: FlowCondition;
+  optional?: boolean;
+  /** Review steps: the text above the submit button. */
+  declaration?: string;
+  /** Review steps in edit mode: whether only changed answers show first (default true). */
+  changesOnly?: boolean;
+}
+
+/** A flow document, the contract C# writes with CanopyFlow and any host can map. */
+export interface FlowDocument {
+  kind: "flow";
+  version: 1;
+  id: string;
+  title: string;
+  description?: string;
+  mode?: "linear" | "free";
+  layout?: { orientation?: "auto" | "horizontal" | "vertical" };
+  density?: "compact" | "normal" | "comfortable";
+  timeZone?: "utc" | "local";
+  steps: readonly FlowStep[];
+  /** Edit mode: the values the flow edits. */
+  initial?: Readonly<Record<string, FlowValue>>;
+  /** Edit mode: the secret fields that already have a stored value. */
+  storedSecrets?: readonly string[];
+  baseline?: string;
+  submit?: { label?: string };
+  labels?: Readonly<Record<string, string>>;
+}
+
+/** The proposal flowSubmit carries: visible answers, secret states, the changes and a JSON patch. Never a secret value. */
+export interface FlowSubmission {
+  kind: "flowSubmission";
+  flow: string;
+  version: 1;
+  mode: "create" | "edit";
+  baseline?: string;
+  values: Record<string, FlowValue>;
+  secrets: Record<string, { state: "set" | "keep" }>;
+  changes: { field: string; path?: string; from: FlowValue; to: FlowValue }[];
+  patch: ({ op: "add" | "replace"; path: string; value: FlowValue } | { op: "remove"; path: string })[];
+}
+
+/** The submit event's detail: the proposal, how to answer it, and each secret once. */
+export interface FlowSubmitDetail extends Readonly<FlowSubmission> {
+  respondWith(answer: FlowAnswer | Promise<FlowAnswer>): void;
+  /** A secret's value, once per field, until the answer settles; null afterwards. */
+  secret(fieldId: string): string | null;
+}
+
+/** The host's answer to a proposal. */
+export interface FlowAnswer {
+  status: "saved" | "accepted" | "error" | "conflict";
+  message?: string;
+  fieldErrors?: Record<string, string>;
+  stepErrors?: Record<string, string>;
+  /** Saved: rows the result panel shows; once rows get Copy and leave the page with the panel. */
+  result?: { label: string; value: string | number | boolean; once?: boolean }[];
+  links?: { label: string; href: string }[];
+}
+
+/** What a step or flow rule answers: a message, or buckets of messages. */
+export type FlowRuleResult = string | null | undefined | { errors?: string[]; warnings?: string[]; fieldErrors?: Record<string, string> };
+
+/** The host's hooks; each runs isolated, and a failure becomes a message in place and an error event. */
+export interface FlowHooks {
+  validators?: Record<string, (value: FlowValue, values: Record<string, FlowValue>) => string | null | undefined | Promise<string | null | undefined>>;
+  validateStep?(stepId: string, values: Record<string, FlowValue>): FlowRuleResult | Promise<FlowRuleResult>;
+  validateFlow?(values: Record<string, FlowValue>): FlowRuleResult | Promise<FlowRuleResult>;
+  submit?(detail: FlowSubmitDetail): FlowAnswer | Promise<FlowAnswer>;
+}
+
+/** Options of createFlow and CanopyX.configure for a flow fragment. */
+export interface FlowOptions {
+  flow: FlowDocument;
+  /** Starting answers on top of the defaults or the edited values. */
+  values?: Record<string, FlowValue>;
+  labels?: Record<string, string>;
+  hooks?: FlowHooks;
+  /** Editors for custom fields, as grid editing's (docs/editing.md#custom-editors). */
+  editors?: CanopyPlugin["editors"];
+  onReady?(detail: { flow: string; step: string }): void;
+  onStepChange?(detail: { from: string; to: string }): void;
+  onValueChange?(detail: { field: string; value?: FlowValue; previous?: FlowValue; source: string }): void;
+  onSubmit?(detail: FlowSubmitDetail): FlowAnswer | Promise<FlowAnswer> | void;
+  onSubmitted?(answer: FlowAnswer): void;
+  onReload?(detail: { baseline: string | null }): void;
+}
+
+/** A validation result: the errors and warnings of a step or the whole flow. */
+export interface FlowValidationResult {
+  valid: boolean;
+  errors: { field?: string; step?: string; message: string }[];
+  warnings: { step?: string; message: string }[];
+}
+
+/** A flow's state: the current step, the answers (never secrets) and the completed steps. */
+export interface FlowState { step: string; values: Record<string, FlowValue>; completed: string[] }
+
+/**
+ * The flow's API. Async methods wait for ready; synchronous methods throw a not-ready error until the implementation loads.
+ * After destroy, synchronous calls throw a destroyed error and async calls reject with it. Calls still waiting for ready also reject.
+ */
+export interface FlowApi {
+  readonly element: HTMLElement;
+  readonly flow: FlowDocument;
+  /** Resolves after the first step is painted; rejects on mount failure or destruction before readiness. */
+  readonly ready: Promise<FlowApi>;
+  next(): Promise<boolean>;
+  back(): Promise<boolean>;
+  goTo(stepId: string): Promise<boolean>;
+  getStep(): string;
+  getValues(): Record<string, FlowValue>;
+  setValues(values: Record<string, FlowValue>): void;
+  getState(): FlowState;
+  setState(state: Partial<FlowState>): Promise<boolean>;
+  isDirty(): boolean;
+  reset(): boolean;
+  validate(stepId?: string): Promise<FlowValidationResult>;
+  setFieldError(fieldId: string, message: string | null): void;
+  submit(): Promise<FlowAnswer | null>;
+  setProgress(progress: { done?: number; total?: number; message?: string }): boolean;
+  complete(answer: FlowAnswer): boolean;
+  /** Releases the flow and its host's mount state, even before ready or after mount failure. Repeated calls do nothing. */
+  destroy(): void;
+}
+
+/** Creates a flow in a host element; the forms and flow parts load on first use. */
+export declare function createFlow(host: HTMLElement, options: FlowOptions): FlowApi;
+/** Registers options for a flow fragment before it mounts; returns a disposer. */
+export declare function configure(flowId: string, options: Partial<Omit<FlowOptions, "flow">>): () => void;
+export declare function unconfigure(flowId: string): boolean;
+/** Mounts the flow fragments under root, or root itself. */
+export declare function mount(root?: ParentNode): FlowApi[];
+/** Registers a plugin's editors for the flows created afterwards; returns a disposer. */
+export declare function use(plugin: Pick<CanopyPlugin, "name" | "editors">): () => void;
+export declare function registerPart(name: string, part: { version: string; requires?: string[]; install(context: object): void }): void;
+export declare function setNonce(nonce: string): void;
+declare const CanopyX: { createFlow: typeof createFlow; configure: typeof configure; unconfigure: typeof unconfigure; mount: typeof mount;
+  use: typeof use; registerPart: typeof registerPart; setNonce: typeof setNonce };
+export default CanopyX;

package/JavaScript/grid.d.ts

@@ -931,14 +931,20 @@ export function createDataGrid<Row extends GridRow = GridRow>(host: HTMLElement,
 export function createDataGrid<Row extends GridRow = GridRow>(host: HTMLElement, options: CursorGridOptions<GridNamedRow<Row>>): DataGrid<GridCursorQuery, Row>;
 /** A calendar from a list of events, with no grid schema to write: a preset (basic by default) and options over it (calendar.d.ts). */
 export function createCalendar(host: HTMLElement, options?: CalendarOptions): DataGrid<GridQuery, GridRow>;
-/** Registers options before either a tree or flat-grid fragment mounts. */
-export function configure(viewId: string, options: HostOptions | GridHostOptions | GridHostOptions<GridCursorQuery>): () => void;
+/** Registers options before a tree, flat-grid, flow or matrix fragment mounts. */
+export function configure(viewId: string, options: HostOptions | GridHostOptions | GridHostOptions<GridCursorQuery> | Partial<Omit<FlowOptions, "flow">> | Partial<Omit<MatrixOptions, "view">>): () => void;
 /**
- * Mounts tree and flat-grid fragments below root, or root itself when it is a fragment. Fragments marked
+ * Mounts tree, flat-grid, flow and matrix fragments below root, or root itself when it is a fragment. Fragments marked
  * `data-cx-mount="visible"` below root wait until they come near the viewport; passing such a fragment as root mounts it at once.
  * Narrow a controller before using view-specific methods.
  */
-export function mount(root?: ParentNode): Array<TreeGrid | DataGrid<AcceptedGridQuery>>;
+export function mount(root?: ParentNode): Array<TreeGrid | DataGrid<AcceptedGridQuery> | FlowApi | MatrixApi>;
 
-declare const gridRuntime: Omit<typeof CanopyX, "configure" | "mount"> & { createDataGrid: typeof createDataGrid; createCalendar: typeof createCalendar; enhance: typeof enhance; grid: typeof grid; configure: typeof configure; mount: typeof mount };
+import type { createFlow, FlowApi, FlowOptions } from "./flow.js";
+export { createFlow } from "./flow.js";
+export type { FlowDocument, FlowField, FlowStep, FlowSection, FlowOption, FlowCondition, FlowValidation, FlowValue, FlowSubmission, FlowSubmitDetail, FlowAnswer, FlowHooks, FlowOptions, FlowApi, FlowState, FlowValidationResult } from "./flow.js";
+import type { createMatrix, MatrixOptions, MatrixApi } from "./matrix.js";
+export { createMatrix } from "./matrix.js";
+export type { MatrixDocument, MatrixAxis, MatrixItem, MatrixAttribute, MatrixState, MatrixSort, MatrixNote, MatrixQueryState, MatrixStateInput, MatrixCellDetail, MatrixOptions, MatrixApi } from "./matrix.js";
+declare const gridRuntime: Omit<typeof CanopyX, "configure" | "mount"> & { createDataGrid: typeof createDataGrid; createCalendar: typeof createCalendar; createFlow: typeof createFlow; createMatrix: typeof createMatrix; enhance: typeof enhance; grid: typeof grid; configure: typeof configure; mount: typeof mount };
 export default gridRuntime;

package/JavaScript/locales/de.mjs

@@ -516,6 +516,111 @@ const labels = Object.freeze({
   calendarOutsideRange: "Außerhalb des Zeitraums dieses Kalenders",
   calendarClose: "Schließen",
   calendarDetailsOf: "Details zu {title}",
+  flowSteps: "Schritte",
+  flowStepOf: "Schritt {current} von {count}",
+  flowStepAnnounce: "Schritt {current} von {count}, {title}",
+  flowNext: "Weiter",
+  flowBack: "Zurück",
+  flowSubmit: "Senden",
+  flowSubmitting: "Wird gesendet…",
+  flowReviewTitle: "Angaben prüfen",
+  flowChange: "Ändern",
+  flowChangeField: "{field} ändern",
+  flowNotProvided: "Nicht angegeben",
+  flowOptional: "(optional)",
+  flowStepOptional: "Optional",
+  flowStepComplete: "Erledigt",
+  flowStepCurrent: "Aktueller Schritt",
+  flowStepErrors: "Fehler: {count}",
+  flowStepLocked: "Zuerst die vorherigen Schritte abschließen",
+  flowStepNotStarted: "Nicht begonnen",
+  flowErrorSummary: "Bitte korrigieren Sie diese Angaben, bevor Sie fortfahren",
+  flowReady: "Bereit zum Senden",
+  flowNotReady: "Zu korrigierende Fehler: {count}",
+  flowWarnings: "Warnungen: {count}",
+  flowChangesOnly: "Nur Änderungen anzeigen",
+  flowNoChanges: "Keine Angabe wurde geändert.",
+  flowWas: "Vorher: {value}",
+  flowChangedCount: "Geänderte Angaben: {count}",
+  flowSecretSet: "Festgelegt",
+  flowSecretKept: "Unverändert",
+  flowSecretNotSet: "Nicht festgelegt",
+  flowSecretHint: "Ein Wert ist gespeichert. Leer lassen, um ihn zu behalten.",
+  flowSecretShow: "Anzeigen",
+  flowSecretHide: "Verbergen",
+  flowSecretReveal: "{field} anzeigen",
+  flowOn: "Ein",
+  flowOff: "Aus",
+  flowAdd: "Hinzufügen",
+  flowAddItem: "Zu {field} hinzufügen",
+  flowRemoveItem: "{item} entfernen",
+  flowItemLabel: "{field}, Eintrag {index}",
+  flowSelectAll: "Alle auswählen",
+  flowSelectNone: "Leeren",
+  flowSelectedCount: "{count} von {total} ausgewählt",
+  flowUnit: "Einheit",
+  flowUnitSeconds: "Sekunden",
+  flowUnitMinutes: "Minuten",
+  flowUnitHours: "Stunden",
+  flowUnitDays: "Tage",
+  flowSeconds: "[one]{count} Sekunde[other]{count} Sekunden",
+  flowMinutes: "[one]{count} Minute[other]{count} Minuten",
+  flowHours: "[one]{count} Stunde[other]{count} Stunden",
+  flowDays: "[one]{count} Tag[other]{count} Tage",
+  flowDurationInvalid: "{field} muss eine ganze Zahl sein.",
+  flowItemsMin: "{field} braucht mindestens {min}.",
+  flowItemsMax: "{field} erlaubt höchstens {max}.",
+  flowItemEmail: "„{item}“ ist keine E-Mail-Adresse.",
+  flowItemHost: "„{item}“ ist kein Hostname.",
+  flowItemIp: "„{item}“ ist keine IP-Adresse.",
+  flowItemCidr: "„{item}“ ist kein Netzwerkbereich.",
+  flowItemUrl: "„{item}“ ist keine Webadresse.",
+  flowItemPattern: "„{item}“ hat nicht das erwartete Format.",
+  flowSaved: "Gespeichert",
+  flowAccepted: "In Bearbeitung",
+  flowProgress: "{done} von {total}",
+  flowConflict: "Diese Einstellungen wurden während Ihrer Bearbeitung geändert.",
+  flowReload: "Aktuelle Einstellungen neu laden",
+  flowNotSubmitted: "Die Angaben wurden nicht gesendet.",
+  flowNoHost: "Kein Host hat die Angaben empfangen.",
+  flowStartAgain: "Neu beginnen",
+  flowCopy: "Kopieren",
+  flowCopied: "Kopiert",
+  flowSavedIt: "Ich habe es gespeichert",
+  flowShownOnce: "Wird nur einmal angezeigt. Jetzt kopieren.",
+  matrixRows: "Zeilen",
+  matrixColumns: "Spalten",
+  matrixSearch: "Zeilen und Spalten suchen",
+  matrixSortBy: "Sortieren nach",
+  matrixGroupBy: "Gruppieren nach",
+  matrixByLabel: "Name",
+  matrixByTotal: "Gesamt",
+  matrixAsListed: "Wie aufgeführt",
+  matrixNoGrouping: "Keine Gruppen",
+  matrixDescending: "Absteigend",
+  matrixOnlyProblems: "Nur Probleme",
+  matrixHideEmpty: "Leere Zeilen und Spalten ausblenden",
+  matrixSize: "{rows} × {columns}",
+  matrixShown: "Zeilen: {rows} von {totalRows}, Spalten: {columns} von {totalColumns}",
+  matrixAttention: "Erfordert Aufmerksamkeit: {count}",
+  matrixLegend: "Zustände",
+  matrixFilter: "Filtern",
+  matrixClearFilters: "Filter löschen",
+  matrixNoMatches: "Keine Zeilen oder Spalten passen.",
+  matrixSelf: "Dasselbe Element",
+  matrixNoData: "Keine Daten",
+  matrixCell: "{row} und {column}: {state}",
+  matrixTotal: "Gesamt",
+  matrixItemTotal: "{item}: {count}",
+  matrixExpandGroup: "{group} aufklappen",
+  matrixCollapseGroup: "{group} zuklappen",
+  matrixGroupCount: "Elemente: {count}",
+  matrixDetails: "Details",
+  matrixClose: "Schließen",
+  matrixValue: "Wert",
+  matrixState: "Zustand",
+  matrixAllClear: "Nichts erfordert Aufmerksamkeit",
+  matrixShowMore: "Mehr anzeigen",
 });
 const staticLabels = Object.freeze({
   overflowNote: "{shown} Zeilen angezeigt. Gesamtzahl: {total}.",

package/JavaScript/locales/es.mjs

@@ -516,6 +516,111 @@ const labels = Object.freeze({
   calendarOutsideRange: "Fuera de las fechas que muestra este calendario",
   calendarClose: "Cerrar",
   calendarDetailsOf: "Detalles de {title}",
+  flowSteps: "Pasos",
+  flowStepOf: "Paso {current} de {count}",
+  flowStepAnnounce: "Paso {current} de {count}, {title}",
+  flowNext: "Siguiente",
+  flowBack: "Atrás",
+  flowSubmit: "Enviar",
+  flowSubmitting: "Enviando…",
+  flowReviewTitle: "Revise sus respuestas",
+  flowChange: "Cambiar",
+  flowChangeField: "Cambiar {field}",
+  flowNotProvided: "No indicado",
+  flowOptional: "(opcional)",
+  flowStepOptional: "Opcional",
+  flowStepComplete: "Completado",
+  flowStepCurrent: "Paso actual",
+  flowStepErrors: "Errores: {count}",
+  flowStepLocked: "Complete primero los pasos anteriores",
+  flowStepNotStarted: "Sin empezar",
+  flowErrorSummary: "Corrija esto antes de continuar",
+  flowReady: "Listo para enviar",
+  flowNotReady: "Errores por corregir: {count}",
+  flowWarnings: "Advertencias: {count}",
+  flowChangesOnly: "Mostrar solo los cambios",
+  flowNoChanges: "No ha cambiado ninguna respuesta.",
+  flowWas: "Antes: {value}",
+  flowChangedCount: "Respuestas cambiadas: {count}",
+  flowSecretSet: "Establecido",
+  flowSecretKept: "Sin cambios",
+  flowSecretNotSet: "Sin establecer",
+  flowSecretHint: "Hay un valor guardado. Déjelo en blanco para conservarlo.",
+  flowSecretShow: "Mostrar",
+  flowSecretHide: "Ocultar",
+  flowSecretReveal: "Mostrar {field}",
+  flowOn: "Activado",
+  flowOff: "Desactivado",
+  flowAdd: "Añadir",
+  flowAddItem: "Añadir a {field}",
+  flowRemoveItem: "Quitar {item}",
+  flowItemLabel: "{field}, elemento {index}",
+  flowSelectAll: "Seleccionar todo",
+  flowSelectNone: "Borrar",
+  flowSelectedCount: "{count} de {total} seleccionados",
+  flowUnit: "Unidad",
+  flowUnitSeconds: "segundos",
+  flowUnitMinutes: "minutos",
+  flowUnitHours: "horas",
+  flowUnitDays: "días",
+  flowSeconds: "[one]{count} segundo[other]{count} segundos",
+  flowMinutes: "[one]{count} minuto[other]{count} minutos",
+  flowHours: "[one]{count} hora[other]{count} horas",
+  flowDays: "[one]{count} día[other]{count} días",
+  flowDurationInvalid: "{field} debe ser un número entero.",
+  flowItemsMin: "{field} necesita al menos {min}.",
+  flowItemsMax: "{field} admite como máximo {max}.",
+  flowItemEmail: "«{item}» no es una dirección de correo.",
+  flowItemHost: "«{item}» no es un nombre de host.",
+  flowItemIp: "«{item}» no es una dirección IP.",
+  flowItemCidr: "«{item}» no es un rango de red.",
+  flowItemUrl: "«{item}» no es una dirección web.",
+  flowItemPattern: "«{item}» no tiene el formato esperado.",
+  flowSaved: "Guardado",
+  flowAccepted: "En curso",
+  flowProgress: "{done} de {total}",
+  flowConflict: "Esta configuración cambió mientras la editaba.",
+  flowReload: "Volver a cargar la configuración actual",
+  flowNotSubmitted: "Las respuestas no se enviaron.",
+  flowNoHost: "Ningún host recibió las respuestas.",
+  flowStartAgain: "Empezar otro",
+  flowCopy: "Copiar",
+  flowCopied: "Copiado",
+  flowSavedIt: "Lo he guardado",
+  flowShownOnce: "Se muestra solo una vez. Cópielo ahora.",
+  matrixRows: "Filas",
+  matrixColumns: "Columnas",
+  matrixSearch: "Buscar filas y columnas",
+  matrixSortBy: "Ordenar por",
+  matrixGroupBy: "Agrupar por",
+  matrixByLabel: "Nombre",
+  matrixByTotal: "Total",
+  matrixAsListed: "Como en la lista",
+  matrixNoGrouping: "Sin grupos",
+  matrixDescending: "Descendente",
+  matrixOnlyProblems: "Solo problemas",
+  matrixHideEmpty: "Ocultar filas y columnas vacías",
+  matrixSize: "{rows} × {columns}",
+  matrixShown: "Filas: {rows} de {totalRows}, columnas: {columns} de {totalColumns}",
+  matrixAttention: "Requieren atención: {count}",
+  matrixLegend: "Estados",
+  matrixFilter: "Filtrar",
+  matrixClearFilters: "Borrar filtros",
+  matrixNoMatches: "Ninguna fila o columna coincide.",
+  matrixSelf: "El mismo elemento",
+  matrixNoData: "Sin datos",
+  matrixCell: "{row} y {column}: {state}",
+  matrixTotal: "Total",
+  matrixItemTotal: "{item}: {count}",
+  matrixExpandGroup: "Expandir {group}",
+  matrixCollapseGroup: "Contraer {group}",
+  matrixGroupCount: "Elementos: {count}",
+  matrixDetails: "Detalles",
+  matrixClose: "Cerrar",
+  matrixValue: "Valor",
+  matrixState: "Estado",
+  matrixAllClear: "Nada requiere atención",
+  matrixShowMore: "Mostrar más",
 });
 const staticLabels = Object.freeze({
   overflowNote: "Filas mostradas: {shown}. Total: {total}.",

package/JavaScript/locales/fr.mjs

@@ -516,6 +516,111 @@ const labels = Object.freeze({
   calendarOutsideRange: "En dehors des dates de ce calendrier",
   calendarClose: "Fermer",
   calendarDetailsOf: "Détails de {title}",
+  flowSteps: "Étapes",
+  flowStepOf: "Étape {current} sur {count}",
+  flowStepAnnounce: "Étape {current} sur {count}, {title}",
+  flowNext: "Suivant",
+  flowBack: "Retour",
+  flowSubmit: "Envoyer",
+  flowSubmitting: "Envoi…",
+  flowReviewTitle: "Vérifiez vos réponses",
+  flowChange: "Modifier",
+  flowChangeField: "Modifier {field}",
+  flowNotProvided: "Non renseigné",
+  flowOptional: "(facultatif)",
+  flowStepOptional: "Facultative",
+  flowStepComplete: "Terminée",
+  flowStepCurrent: "Étape actuelle",
+  flowStepErrors: "Erreurs : {count}",
+  flowStepLocked: "Terminez d'abord les étapes précédentes",
+  flowStepNotStarted: "Non commencée",
+  flowErrorSummary: "Corrigez ces points avant de continuer",
+  flowReady: "Prêt à envoyer",
+  flowNotReady: "Erreurs à corriger : {count}",
+  flowWarnings: "Avertissements : {count}",
+  flowChangesOnly: "Afficher uniquement les modifications",
+  flowNoChanges: "Aucune réponse n'a changé.",
+  flowWas: "Avant : {value}",
+  flowChangedCount: "Réponses modifiées : {count}",
+  flowSecretSet: "Défini",
+  flowSecretKept: "Inchangé",
+  flowSecretNotSet: "Non défini",
+  flowSecretHint: "Une valeur est enregistrée. Laissez vide pour la conserver.",
+  flowSecretShow: "Afficher",
+  flowSecretHide: "Masquer",
+  flowSecretReveal: "Afficher {field}",
+  flowOn: "Activé",
+  flowOff: "Désactivé",
+  flowAdd: "Ajouter",
+  flowAddItem: "Ajouter à {field}",
+  flowRemoveItem: "Retirer {item}",
+  flowItemLabel: "{field}, élément {index}",
+  flowSelectAll: "Tout sélectionner",
+  flowSelectNone: "Effacer",
+  flowSelectedCount: "{count} sur {total} sélectionnés",
+  flowUnit: "Unité",
+  flowUnitSeconds: "secondes",
+  flowUnitMinutes: "minutes",
+  flowUnitHours: "heures",
+  flowUnitDays: "jours",
+  flowSeconds: "[one]{count} seconde[other]{count} secondes",
+  flowMinutes: "[one]{count} minute[other]{count} minutes",
+  flowHours: "[one]{count} heure[other]{count} heures",
+  flowDays: "[one]{count} jour[other]{count} jours",
+  flowDurationInvalid: "{field} doit être un nombre entier.",
+  flowItemsMin: "{field} : au moins {min}.",
+  flowItemsMax: "{field} : au plus {max}.",
+  flowItemEmail: "« {item} » n'est pas une adresse e-mail.",
+  flowItemHost: "« {item} » n'est pas un nom d'hôte.",
+  flowItemIp: "« {item} » n'est pas une adresse IP.",
+  flowItemCidr: "« {item} » n'est pas une plage réseau.",
+  flowItemUrl: "« {item} » n'est pas une adresse web.",
+  flowItemPattern: "« {item} » n'a pas le format attendu.",
+  flowSaved: "Enregistré",
+  flowAccepted: "En cours",
+  flowProgress: "{done} sur {total}",
+  flowConflict: "Ces paramètres ont changé pendant que vous les modifiiez.",
+  flowReload: "Recharger les paramètres actuels",
+  flowNotSubmitted: "Les réponses n'ont pas été envoyées.",
+  flowNoHost: "Aucun hôte n'a reçu les réponses.",
+  flowStartAgain: "Recommencer",
+  flowCopy: "Copier",
+  flowCopied: "Copié",
+  flowSavedIt: "Je l'ai enregistré",
+  flowShownOnce: "Affiché une seule fois. Copiez-le maintenant.",
+  matrixRows: "Lignes",
+  matrixColumns: "Colonnes",
+  matrixSearch: "Rechercher des lignes et des colonnes",
+  matrixSortBy: "Trier par",
+  matrixGroupBy: "Regrouper par",
+  matrixByLabel: "Nom",
+  matrixByTotal: "Total",
+  matrixAsListed: "Comme listé",
+  matrixNoGrouping: "Aucun groupe",
+  matrixDescending: "Décroissant",
+  matrixOnlyProblems: "Problèmes uniquement",
+  matrixHideEmpty: "Masquer les lignes et colonnes vides",
+  matrixSize: "{rows} × {columns}",
+  matrixShown: "Lignes : {rows} sur {totalRows}, colonnes : {columns} sur {totalColumns}",
+  matrixAttention: "À examiner : {count}",
+  matrixLegend: "États",
+  matrixFilter: "Filtrer",
+  matrixClearFilters: "Effacer les filtres",
+  matrixNoMatches: "Aucune ligne ni colonne ne correspond.",
+  matrixSelf: "Même élément",
+  matrixNoData: "Aucune donnée",
+  matrixCell: "{row} et {column} : {state}",
+  matrixTotal: "Total",
+  matrixItemTotal: "{item} : {count}",
+  matrixExpandGroup: "Développer {group}",
+  matrixCollapseGroup: "Réduire {group}",
+  matrixGroupCount: "Éléments : {count}",
+  matrixDetails: "Détails",
+  matrixClose: "Fermer",
+  matrixValue: "Valeur",
+  matrixState: "État",
+  matrixAllClear: "Rien à examiner",
+  matrixShowMore: "Afficher plus",
 });
 const staticLabels = Object.freeze({
   overflowNote: "{shown} lignes affichées sur {total}.",