@evotecit/canopyx 0.2.2 → 0.3.3

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,17 @@ 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 or flow fragment mounts. */
+export function configure(viewId: string, options: HostOptions | GridHostOptions | GridHostOptions<GridCursorQuery> | Partial<Omit<FlowOptions, "flow">>): () => void;
 /**
- * Mounts tree and flat-grid fragments below root, or root itself when it is a fragment. Fragments marked
+ * Mounts tree, flat-grid and flow 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>;
 
-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";
+declare const gridRuntime: Omit<typeof CanopyX, "configure" | "mount"> & { createDataGrid: typeof createDataGrid; createCalendar: typeof createCalendar; createFlow: typeof createFlow; enhance: typeof enhance; grid: typeof grid; configure: typeof configure; mount: typeof mount };
 export default gridRuntime;

package/JavaScript/hosts.d.ts

@@ -102,6 +102,8 @@ export interface ExportFormat<C extends ExportCapture = ExportCapture> {
   readonly extension: string;
   /** The Blob type for bytes a writer returns; default application/octet-stream. */
   readonly mime?: string;
+  /** False omits this writer from the Export menu; exportAs still runs it. Default true. */
+  readonly showInMenu?: boolean;
   /** Returns the file: a Blob (a File names the download itself), or bytes typed with mime. */
   write(capture: C, context: ExportFormatContext): Blob | ArrayBuffer | ArrayBufferView | PromiseLike<Blob | ArrayBuffer | ArrayBufferView>;
 }
@@ -281,4 +283,4 @@ export interface LinkedView {
   getHighlight(): string[];
   /** Starts canopyx:linkchange on a view created without linkEvents (for hosts that link views after they mount). */
   startLinkEvents(): Promise<void>;
-}
+}

package/JavaScript/locales/de.mjs

@@ -516,6 +516,78 @@ 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.",
 });
 const staticLabels = Object.freeze({
   overflowNote: "{shown} Zeilen angezeigt. Gesamtzahl: {total}.",

package/JavaScript/locales/es.mjs

@@ -516,6 +516,78 @@ 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.",
 });
 const staticLabels = Object.freeze({
   overflowNote: "Filas mostradas: {shown}. Total: {total}.",

package/JavaScript/locales/fr.mjs

@@ -516,6 +516,78 @@ 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.",
 });
 const staticLabels = Object.freeze({
   overflowNote: "{shown} lignes affichées sur {total}.",

package/JavaScript/locales/it.mjs

@@ -516,6 +516,78 @@ const labels = Object.freeze({
   calendarOutsideRange: "Al di fuori delle date di questo calendario",
   calendarClose: "Chiudi",
   calendarDetailsOf: "Dettagli di {title}",
+  flowSteps: "Passaggi",
+  flowStepOf: "Passaggio {current} di {count}",
+  flowStepAnnounce: "Passaggio {current} di {count}, {title}",
+  flowNext: "Avanti",
+  flowBack: "Indietro",
+  flowSubmit: "Invia",
+  flowSubmitting: "Invio in corso…",
+  flowReviewTitle: "Controlla le risposte",
+  flowChange: "Modifica",
+  flowChangeField: "Modifica {field}",
+  flowNotProvided: "Non indicato",
+  flowOptional: "(facoltativo)",
+  flowStepOptional: "Facoltativo",
+  flowStepComplete: "Completato",
+  flowStepCurrent: "Passaggio corrente",
+  flowStepErrors: "Errori: {count}",
+  flowStepLocked: "Completa prima i passaggi precedenti",
+  flowStepNotStarted: "Non iniziato",
+  flowErrorSummary: "Correggi questi punti prima di continuare",
+  flowReady: "Pronto per l'invio",
+  flowNotReady: "Errori da correggere: {count}",
+  flowWarnings: "Avvisi: {count}",
+  flowChangesOnly: "Mostra solo le modifiche",
+  flowNoChanges: "Nessuna risposta è cambiata.",
+  flowWas: "Prima: {value}",
+  flowChangedCount: "Risposte modificate: {count}",
+  flowSecretSet: "Impostato",
+  flowSecretKept: "Invariato",
+  flowSecretNotSet: "Non impostato",
+  flowSecretHint: "È salvato un valore. Lascia vuoto per mantenerlo.",
+  flowSecretShow: "Mostra",
+  flowSecretHide: "Nascondi",
+  flowSecretReveal: "Mostra {field}",
+  flowOn: "Attivo",
+  flowOff: "Disattivo",
+  flowAdd: "Aggiungi",
+  flowAddItem: "Aggiungi a {field}",
+  flowRemoveItem: "Rimuovi {item}",
+  flowItemLabel: "{field}, elemento {index}",
+  flowSelectAll: "Seleziona tutto",
+  flowSelectNone: "Cancella",
+  flowSelectedCount: "{count} di {total} selezionati",
+  flowUnit: "Unità",
+  flowUnitSeconds: "secondi",
+  flowUnitMinutes: "minuti",
+  flowUnitHours: "ore",
+  flowUnitDays: "giorni",
+  flowSeconds: "[one]{count} secondo[other]{count} secondi",
+  flowMinutes: "[one]{count} minuto[other]{count} minuti",
+  flowHours: "[one]{count} ora[other]{count} ore",
+  flowDays: "[one]{count} giorno[other]{count} giorni",
+  flowDurationInvalid: "{field} deve essere un numero intero.",
+  flowItemsMin: "{field} richiede almeno {min}.",
+  flowItemsMax: "{field} ne consente al massimo {max}.",
+  flowItemEmail: "«{item}» non è un indirizzo email.",
+  flowItemHost: "«{item}» non è un nome host.",
+  flowItemIp: "«{item}» non è un indirizzo IP.",
+  flowItemCidr: "«{item}» non è un intervallo di rete.",
+  flowItemUrl: "«{item}» non è un indirizzo web.",
+  flowItemPattern: "«{item}» non ha il formato previsto.",
+  flowSaved: "Salvato",
+  flowAccepted: "In corso",
+  flowProgress: "{done} di {total}",
+  flowConflict: "Queste impostazioni sono cambiate durante la modifica.",
+  flowReload: "Ricarica le impostazioni correnti",
+  flowNotSubmitted: "Le risposte non sono state inviate.",
+  flowNoHost: "Nessun host ha ricevuto le risposte.",
+  flowStartAgain: "Ricomincia",
+  flowCopy: "Copia",
+  flowCopied: "Copiato",
+  flowSavedIt: "L'ho salvato",
+  flowShownOnce: "Mostrato una sola volta. Copialo ora.",
 });
 const staticLabels = Object.freeze({
   overflowNote: "Righe mostrate: {shown} su {total}.",

package/JavaScript/locales/pl.mjs

@@ -516,6 +516,78 @@ const labels = Object.freeze({
   calendarOutsideRange: "Poza datami, które pokazuje ten kalendarz",
   calendarClose: "Zamknij",
   calendarDetailsOf: "Szczegóły: {title}",
+  flowSteps: "Kroki",
+  flowStepOf: "Krok {current} z {count}",
+  flowStepAnnounce: "Krok {current} z {count}: {title}",
+  flowNext: "Dalej",
+  flowBack: "Wstecz",
+  flowSubmit: "Wyślij",
+  flowSubmitting: "Wysyłanie…",
+  flowReviewTitle: "Sprawdź odpowiedzi",
+  flowChange: "Zmień",
+  flowChangeField: "Zmień: {field}",
+  flowNotProvided: "Nie podano",
+  flowOptional: "(opcjonalnie)",
+  flowStepOptional: "Opcjonalny",
+  flowStepComplete: "Ukończono",
+  flowStepCurrent: "Bieżący krok",
+  flowStepErrors: "Błędy: {count}",
+  flowStepLocked: "Najpierw ukończ wcześniejsze kroki",
+  flowStepNotStarted: "Nierozpoczęty",
+  flowErrorSummary: "Popraw te pola, zanim przejdziesz dalej",
+  flowReady: "Gotowe do wysłania",
+  flowNotReady: "Błędy do poprawienia: {count}",
+  flowWarnings: "Ostrzeżenia: {count}",
+  flowChangesOnly: "Pokaż tylko zmiany",
+  flowNoChanges: "Żadna odpowiedź się nie zmieniła.",
+  flowWas: "Było: {value}",
+  flowChangedCount: "Zmienione odpowiedzi: {count}",
+  flowSecretSet: "Ustawiono",
+  flowSecretKept: "Bez zmian",
+  flowSecretNotSet: "Nie ustawiono",
+  flowSecretHint: "Wartość jest zapisana. Zostaw puste, aby ją zachować.",
+  flowSecretShow: "Pokaż",
+  flowSecretHide: "Ukryj",
+  flowSecretReveal: "Pokaż: {field}",
+  flowOn: "Włączone",
+  flowOff: "Wyłączone",
+  flowAdd: "Dodaj",
+  flowAddItem: "Dodaj do: {field}",
+  flowRemoveItem: "Usuń: {item}",
+  flowItemLabel: "{field}, pozycja {index}",
+  flowSelectAll: "Zaznacz wszystko",
+  flowSelectNone: "Wyczyść",
+  flowSelectedCount: "Zaznaczono {count} z {total}",
+  flowUnit: "Jednostka",
+  flowUnitSeconds: "sekundy",
+  flowUnitMinutes: "minuty",
+  flowUnitHours: "godziny",
+  flowUnitDays: "dni",
+  flowSeconds: "[one]{count} sekunda[few]{count} sekundy[many]{count} sekund[other]{count} sekundy",
+  flowMinutes: "[one]{count} minuta[few]{count} minuty[many]{count} minut[other]{count} minuty",
+  flowHours: "[one]{count} godzina[few]{count} godziny[many]{count} godzin[other]{count} godziny",
+  flowDays: "[one]{count} dzień[few]{count} dni[many]{count} dni[other]{count} dnia",
+  flowDurationInvalid: "{field}: wpisz liczbę całkowitą.",
+  flowItemsMin: "{field}: wymagane co najmniej {min}.",
+  flowItemsMax: "{field}: dozwolone najwyżej {max}.",
+  flowItemEmail: "„{item}” nie jest adresem e-mail.",
+  flowItemHost: "„{item}” nie jest nazwą hosta.",
+  flowItemIp: "„{item}” nie jest adresem IP.",
+  flowItemCidr: "„{item}” nie jest zakresem sieci.",
+  flowItemUrl: "„{item}” nie jest adresem internetowym.",
+  flowItemPattern: "„{item}” ma nieoczekiwany format.",
+  flowSaved: "Zapisano",
+  flowAccepted: "W toku",
+  flowProgress: "{done} z {total}",
+  flowConflict: "Te ustawienia zmieniły się podczas edycji.",
+  flowReload: "Wczytaj bieżące ustawienia",
+  flowNotSubmitted: "Odpowiedzi nie zostały wysłane.",
+  flowNoHost: "Żaden host nie odebrał odpowiedzi.",
+  flowStartAgain: "Zacznij od nowa",
+  flowCopy: "Kopiuj",
+  flowCopied: "Skopiowano",
+  flowSavedIt: "Mam to zapisane",
+  flowShownOnce: "Widoczne tylko raz. Skopiuj teraz.",
 });
 const staticLabels = Object.freeze({
   overflowNote: "Pokazano {shown} z {total} wierszy.",