@zeitune-sasu/risk-form 0.0.0-stage → 0.1.0

package/types/zeitune-sasu-risk-form.d.ts

@@ -0,0 +1,266 @@
+import { SafeHtml } from '@angular/platform-browser';
+import * as i0 from '@angular/core';
+import { TemplateRef, EventEmitter } from '@angular/core';
+
+/** Le nom stable d'une icône du modèle : lui-même s'il existe, son équivalent s'il est ancien, `document` sinon ; null s'il est vide. */
+declare function resolveRiskIcon(name: string | null | undefined): string | null;
+/** Le SVG complet d'une icône, à la taille du texte. */
+declare function riskIconSvg(name: string | null | undefined): string;
+/** Un pictogramme embarqué : aucun jeu d'icônes à charger, il suit la couleur et la taille du texte. */
+declare class RfIconComponent {
+    private readonly sanitizer;
+    html: SafeHtml;
+    set name(value: string | null | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RfIconComponent, "rf-icon", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Nom stable -> contenu SVG (viewBox 24, trait 2, arrondi). */
+declare const ICON_SVG: Readonly<Record<string, string>>;
+/** Les pictogrammes proposés dans l'éditeur, regroupés comme dans le catalogue. */
+declare const ICON_CATALOG: ReadonlyArray<{
+    name: string;
+    label: string;
+    keywords: string;
+}>;
+
+/** Ce que le rendu sait d'un champ : tout modèle de risque, du front métier comme de l'admin, y répond. */
+interface RfFieldLike {
+    code: string;
+    label: string;
+    valueType: string;
+    width?: number | null;
+    identifier?: boolean;
+    required?: boolean;
+    computed?: boolean;
+    /** La clé de transmission du champ (ancien nom) ; à défaut, son code. */
+    /** Rempli par le système : jamais montré dans le formulaire. */
+    internal?: boolean;
+    options?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }> | null;
+    presentation?: {
+        style?: string | null;
+        icon?: string | null;
+        placeholder?: string | null;
+        trueLabel?: string | null;
+        falseLabel?: string | null;
+    } | null;
+}
+interface RfSectionLike {
+    code: string;
+    title: string;
+    position: number;
+    columns?: number | null;
+    icon?: string | null;
+}
+/** Un bloc du formulaire : le titre de sa section (aucun pour la section par défaut, en tête) et ses champs. */
+interface RfGroup<F = RfFieldLike> {
+    code: string | null;
+    title: string | null;
+    /** Nom stable de l'icône, déjà résolu. */
+    icon: string | null;
+    columns: number;
+    /** Les oui / non en deux boutons, dans l'en-tête de la section. */
+    toggles: F[];
+    /** Les champs de la grille. */
+    fields: F[];
+    /** Les oui / non en tuiles : une rangée sous la grille. */
+    options: F[];
+}
+declare const DEFAULT_COLUMNS = 4;
+declare const MAX_COLUMNS = 12;
+/** Les colonnes d'une section : celles qu'elle déclare (1 à 12), 4 sinon. */
+declare function sectionColumns(section: Pick<RfSectionLike, 'columns'> | null | undefined): number;
+/**
+ * Le nombre de colonnes qu'occupe un champ : sa largeur, sinon un identifiant prend 4, un texte ou une liste 2, le reste 1.
+ * Un champ ne dépasse jamais la grille de sa section.
+ */
+declare function fieldSpan(field: Pick<RfFieldLike, 'width' | 'valueType' | 'identifier'>, columns?: number): number;
+/** La part d'une rangée de 2 colonnes (écran moyen) : un champ pleine largeur prend la rangée, les autres une colonne. */
+declare function midSpan(span: number, columns: number): number;
+/**
+ * Range les champs (déjà triés et filtrés) par section : la section par défaut en tête, puis les sections dans l'ordre du
+ * modèle. `keepEmpty` garde les sections sans champ (l'éditeur les montre pour qu'on y dépose des champs).
+ */
+declare function buildGroups<F extends RfFieldLike>(fields: F[], sections: ReadonlyArray<RfSectionLike> | null | undefined, sectionOf: (field: F) => string | null | undefined, keepEmpty?: boolean): RfGroup<F>[];
+/** Un choix de largeur : une part de la ligne, et le nombre de colonnes qu'elle prend dans la grille de la section. */
+interface WidthChoice {
+    span: number;
+    label: string;
+}
+/** Le libellé d'une largeur : une fraction usuelle, sinon « n/m ». */
+declare function widthLabel(span: number, columns: number): string;
+/**
+ * Les largeurs offertes pour une grille de `columns` colonnes : les fractions qui tombent juste (¼ ½ ¾ pleine pour 4,
+ * ⅓ ½ ⅔ pleine pour 6 ou 12…) ; une section de 3 colonnes ou moins offre chaque colonne. `current` s'ajoute s'il n'y est pas.
+ */
+declare function widthChoices(columns: number, current?: number | null): WidthChoice[];
+/** Une largeur gardée dans la même part de la ligne quand la section change de nombre de colonnes (2 sur 4 → 3 sur 6). */
+declare function rescaleSpan(span: number, from: number, to: number): number;
+/**
+ * Garde les objets d'avant quand rien n'a changé : un formulaire recalcule ses sections à chaque vérification, et un
+ * composant qui reçoit chaque fois de nouveaux objets se redessine pour rien (et Angular s'en plaint en développement).
+ */
+declare function stableGroups<F>(previous: RfGroup<F>[] | null | undefined, next: RfGroup<F>[]): RfGroup<F>[];
+/** Un champ absent du vrai formulaire : calculé, ou interne (rempli par le système). L'éditeur le montre, l'essai non. */
+declare function isHiddenInForm(field: Pick<RfFieldLike, 'computed' | 'internal'>): boolean;
+
+/** Le contexte d'un champ : sa part de la grille de la section, et si c'est un champ de la grille ou une tuile d'option. */
+interface RfFieldContext<F = RfFieldLike> {
+    $implicit: F;
+    group: RfGroup<F>;
+    span: number;
+    mid: number;
+    kind: 'field' | 'option';
+}
+/** Le gabarit d'un champ : `<ng-template rfField let-field let-span="span" let-mid="mid">`. */
+declare class RfFieldTemplateDirective {
+    readonly template: TemplateRef<RfFieldContext<any>>;
+    constructor(template: TemplateRef<RfFieldContext<any>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfFieldTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RfFieldTemplateDirective, "ng-template[rfField]", never, {}, {}, never, never, true, never>;
+}
+/** Ce qui s'ajoute à droite du titre (bascules, modes de saisie…). */
+declare class RfHeaderTemplateDirective {
+    readonly template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>;
+    constructor(template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfHeaderTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RfHeaderTemplateDirective, "ng-template[rfHeader]", never, {}, {}, never, never, true, never>;
+}
+/** Ce qui suit la grille, avant les options (une alerte, par exemple). */
+declare class RfAfterTemplateDirective {
+    readonly template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>;
+    constructor(template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfAfterTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RfAfterTemplateDirective, "ng-template[rfAfter]", never, {}, {}, never, never, true, never>;
+}
+/** Ce qui paraît quand la section n'a aucun champ (l'éditeur y invite à déposer). */
+declare class RfEmptyTemplateDirective {
+    readonly template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>;
+    constructor(template: TemplateRef<{
+        $implicit: RfGroup<any>;
+    }>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfEmptyTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RfEmptyTemplateDirective, "ng-template[rfEmpty]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Une section du formulaire d'un risque : une carte, son icône et son titre, puis la grille de ses champs. C'est le seul
+ * rendu de la structure : le vrai formulaire (front métier) et l'éditeur (admin) l'utilisent tous les deux, avec chacun
+ * son propre contenu de champ.
+ */
+declare class RfSectionComponent {
+    group: RfGroup<any>;
+    /** Montre toujours la grille déclarée, quelle que soit la largeur de la carte (l'éditeur). */
+    forceGrid: boolean;
+    fieldTpl?: RfFieldTemplateDirective;
+    headerTpl?: RfHeaderTemplateDirective;
+    afterTpl?: RfAfterTemplateDirective;
+    emptyTpl?: RfEmptyTemplateDirective;
+    private readonly contexts;
+    /** Un champ avec sa part de grille. Le même objet revient tant que rien ne change : le gabarit ne se redessine pas pour rien. */
+    context(field: RfFieldLike, kind: 'field' | 'option'): RfFieldContext<any>;
+    /** Remplace la largeur lue sur le champ (la largeur d'une autre place, selon une condition). */
+    spanSource?: (field: any) => Pick<RfFieldLike, 'width' | 'valueType' | 'identifier'>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RfSectionComponent, "rf-section", never, { "group": { "alias": "group"; "required": true; }; "forceGrid": { "alias": "forceGrid"; "required": false; }; "spanSource": { "alias": "spanSource"; "required": false; }; }, {}, ["fieldTpl", "headerTpl", "afterTpl", "emptyTpl"], never, true, never>;
+}
+
+/** Le texte que montre un champ vide : ses bornes, ses premiers choix, ou son format. */
+declare function fieldHint(field: RfFieldLike & {
+    min?: string | null;
+    max?: string | null;
+}): string;
+/**
+ * Un champ du formulaire d'un risque, dessiné comme dans le vrai formulaire : l'étiquette au-dessus, un contrôle de la
+ * hauteur commune, l'icône à gauche. Il sert à l'éditeur (contrôles inertes) et à son essai (contrôles actifs).
+ */
+declare class RfFieldPreviewComponent {
+    field: RfFieldLike & {
+        min?: string | null;
+        max?: string | null;
+    };
+    /** Obligatoire maintenant (le champ le dit, ou une condition). */
+    required: boolean;
+    /** Contrôles actifs (l'essai) ; sinon inertes. */
+    interactive: boolean;
+    invalid: boolean;
+    /** Non modifiable (rempli par une fiche, calculé, en lecture seule, verrouillé) : un seul aspect, quelle que soit la cause. */
+    locked: boolean;
+    value: unknown;
+    valueChange: EventEmitter<unknown>;
+    get style(): string | null | undefined;
+    get iconName(): string | null;
+    get placeholder(): string | null;
+    get hint(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfFieldPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RfFieldPreviewComponent, "rf-field-preview", never, { "field": { "alias": "field"; "required": true; }; "required": { "alias": "required"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "locked": { "alias": "locked"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/** Un oui / non en deux boutons, tel qu'il paraît dans l'en-tête d'une section. */
+declare class RfToggleComponent {
+    value: boolean;
+    yesLabel: string | null | undefined;
+    noLabel: string | null | undefined;
+    yesIcon: string;
+    noIcon: string;
+    disabled: boolean;
+    valueChange: EventEmitter<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RfToggleComponent, "rf-toggle", never, { "value": { "alias": "value"; "required": false; }; "yesLabel": { "alias": "yesLabel"; "required": false; }; "noLabel": { "alias": "noLabel"; "required": false; }; "yesIcon": { "alias": "yesIcon"; "required": false; }; "noIcon": { "alias": "noIcon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Le conteneur du formulaire d'un risque : les sections s'y empilent, avec les mesures communes des contrôles
+ * (`--vehicle-control-*`). `themed` pose des valeurs par défaut pour les jetons de couleur, quand l'hôte n'a pas
+ * le thème du front métier (l'admin).
+ */
+declare class RfFormComponent {
+    themed: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RfFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RfFormComponent, "rf-form", never, { "themed": { "alias": "themed"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Une suggestion : sa clé (ce qui se pose dans le champ) et ses lignes d'affichage (la première est le titre). */
+interface RiskSuggestion {
+    key: string;
+    lines: string[];
+}
+/**
+ * La liste de suggestions d'un champ à recherche dans un registre. Une seule source de vérité visuelle : les classes
+ * `.rfv-suggest*` de `risk-form-visual-rules.scss` (aucune dépendance à Tailwind ni à spartan). Le champ garde le focus ;
+ * la navigation au clavier passe par {@link move} et {@link pickActive}, appelées par le champ.
+ */
+declare class RiskSuggestionsComponent {
+    private _items;
+    set items(value: RiskSuggestion[]);
+    get items(): RiskSuggestion[];
+    busy: boolean;
+    picked: EventEmitter<RiskSuggestion>;
+    private entries;
+    /** L'entrée active (clavier ou survol) ; -1 : aucune. */
+    active: number;
+    /** Descend (+1) ou monte (-1) d'une entrée, en boucle, et la garde visible. */
+    move(delta: 1 | -1): void;
+    /** Choisit l'entrée active ; faux s'il n'y en a pas (le champ fait alors sa recherche exacte). */
+    pickActive(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RiskSuggestionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RiskSuggestionsComponent, "app-risk-suggestions", never, { "items": { "alias": "items"; "required": false; }; "busy": { "alias": "busy"; "required": false; }; }, { "picked": "picked"; }, never, never, true, never>;
+}
+
+/** Tout ce qu'un composant (ou un module) importe pour dessiner le formulaire d'un risque. */
+declare const RISK_FORM_IMPORTS: readonly [typeof RfFormComponent, typeof RfSectionComponent, typeof RfFieldTemplateDirective, typeof RfHeaderTemplateDirective, typeof RfAfterTemplateDirective, typeof RfEmptyTemplateDirective, typeof RfFieldPreviewComponent, typeof RfToggleComponent, typeof RfIconComponent, typeof RiskSuggestionsComponent];
+
+export { DEFAULT_COLUMNS, ICON_CATALOG, ICON_SVG, MAX_COLUMNS, RISK_FORM_IMPORTS, RfAfterTemplateDirective, RfEmptyTemplateDirective, RfFieldPreviewComponent, RfFieldTemplateDirective, RfFormComponent, RfHeaderTemplateDirective, RfIconComponent, RfSectionComponent, RfToggleComponent, RiskSuggestionsComponent, buildGroups, fieldHint, fieldSpan, isHiddenInForm, midSpan, rescaleSpan, resolveRiskIcon, riskIconSvg, sectionColumns, stableGroups, widthChoices, widthLabel };
+export type { RfFieldContext, RfFieldLike, RfGroup, RfSectionLike, RiskSuggestion, WidthChoice };