@agridea/suibi-module 0.1.0-preview.c59da9e → 0.1.0-preview.d54bad3

package/dist/elements/browser/version.txt

@@ -1 +1 @@
-0.1.0-preview.c59da9e c59da9e
+0.1.0-preview.d54bad3 d54bad3

package/dist/elements/browser/wc-global-utilities.css

@@ -1 +1 @@
-.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}
+.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}.mat-mdc-option.mdc-list-item{height:auto;min-height:48px}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;overflow:visible;text-overflow:clip;line-height:1.35}

package/dist/types/app/components/data-preview/data-preview.component.d.ts

@@ -3,9 +3,231 @@ import { PlanningBalanceService } from '../../core/planning/planning-balance.ser
 export declare class DataPreviewComponent {
     private readonly host;
     private readonly emitter;
+    private readonly clipboard;
     readonly planning: PlanningBalanceService;
     readonly naebi: NaebiDataService;
     readonly metadataPreview: import("@angular/core").Signal<import("../../../public-api").SuibiDataEventMetadata>;
+    /** Exact payload that runPlanning will POST (same builder as the real request). */
+    readonly apiPayload: import("@angular/core").Signal<{
+        nutrientCycle: {
+            animalStock: {
+                order: string;
+                animalCategoryPRIF: number;
+                selfReportedLivestock: {
+                    averageQuantity: number;
+                };
+                durationCorrectionQuantity: number;
+                durationCorrectionDays: number;
+                utilisation: number;
+                formOfDetention: {
+                    hasGrazing: boolean;
+                    pasture: {
+                        days: number;
+                        hoursPerDay: number;
+                    };
+                    stall: {
+                        stableSystem: string;
+                        stableVentilationType: number;
+                        hasStableDeepLitter: boolean;
+                        hasStableManureBeltDrying: boolean;
+                        stableManureRemovalFrequency: number;
+                        stableWaterSupply: number;
+                        hasStableManureAndSlurryProduction: boolean;
+                        hasStableFeedingStationElevated: boolean;
+                        hasStableFloorSlopedUrineDrainage: boolean;
+                        hasYard: boolean;
+                    };
+                };
+                hasImpexDerivedExcretion: boolean;
+                hasLinearCorrectionDerivedExcretion: boolean;
+                feeding: {
+                    fodderConsumption: number;
+                    concentratedFeedstuffConsumption: number;
+                    concentratedFeedStuffConsumption: number;
+                    winterFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                    summerFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                };
+            }[];
+            storage: {
+                stableStrawLitter: number;
+                slurrySupplyProportionStored: number;
+                createFacilitySpecificManureProduct: boolean;
+                createFacilitySpecificSlurryProduct: boolean;
+                slurryTankQuantity: number;
+                dilutionRatio: number;
+                manurePit: never[];
+                slurryTank: {
+                    descriptor: string;
+                    volumeInM3: number;
+                    depthInM: number;
+                    cover: number;
+                    mixingFrequency: number;
+                    manureDerivation: string[];
+                }[];
+            };
+            farmManureTrading: {
+                supply: never[];
+                dispense: {
+                    quantity: number;
+                    typeOfManureRecyclingProduct: string;
+                    transactionUnit: string;
+                    manureDerivation: {
+                        zoologicalAnimal: string;
+                        percentageAllocation: number;
+                    }[];
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            fieldSpreading: {
+                soilPh: number;
+                slurry: {
+                    quantity: number;
+                    dilutionRatio: number;
+                    otherApplicationTechnologies: {
+                        applicationTechnologyType: number;
+                        proportionOfArea: number;
+                    }[];
+                    applicationDuringWarmDays: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                    proportionAppliedAfter6PM: number;
+                    dragHoseAreaSize: number;
+                };
+                manure: {
+                    applicationIncorporationTime: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                };
+                fertiliser: {
+                    descriptor: string;
+                    fertiliserProductCategory: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+                recycling: {
+                    typeOfManureRecyclingProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            lifetimePerformance: {
+                milkProductionReport: number;
+            };
+            fodder: {
+                trading: {
+                    supply: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: {
+                            quantity: number;
+                            molecularFormula: string;
+                            unit: string;
+                        }[];
+                    }[];
+                    dispense: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: never[];
+                    }[];
+                };
+                cropFromNonFodderCropland: {
+                    typeOfFeedstuffProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+                proportionStorageLoss: number;
+                totalBalanceErrorMargin: number;
+            };
+            fieldCultivation: {
+                buildingZoneAreaSize: number;
+                outdoorVegetableMainCropAreaSize: number;
+                indoorVegetableMainCropAreaSize: number;
+                feedingOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                dispenseOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                fodderCropland: ({
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    calculateYieldThroughFodderBalance: boolean;
+                    yieldPerSquareMeasure?: undefined;
+                } | {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    calculateYieldThroughFodderBalance?: undefined;
+                })[];
+                arableLand: {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    hasLongTermYieldDivergence: boolean;
+                }[];
+                special: {
+                    agronomicCropCategory: string;
+                    userSpecificPlantName: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    requirementCorrection: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            generateReport: boolean;
+        };
+        calculationVersion: {
+            version: string;
+        };
+    }>;
     setPlanningEndpoint(value: string | null): void;
     emitData(): void;
+    copyJson(getValue: () => unknown): void;
 }

package/dist/types/app/components/inline-table/inline-table.component.d.ts

@@ -1,5 +1,7 @@
+import { MatCheckboxChange } from '@angular/material/checkbox';
 import { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
-import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
+import { SearchableSelectOption } from '../../jsonforms/shared/searchable-select/searchable-select.component';
+import { InlineColumnDef, InlineTableConfig, InlineCellErrorResolver } from './inline-table.types';
 /**
  * InlineTableComponent — generic inline-editable table for array-of-objects data.
  *
@@ -26,6 +28,8 @@ import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
  */
 export declare class InlineTableComponent {
     private readonly i18n;
+    private readonly host;
+    constructor();
     /** Table configuration — columns, labels, and the row factory. Acts as the "uischema". */
     readonly config: import("@angular/core").InputSignal<InlineTableConfig>;
     /** Current array of row objects. Each key maps to a column's `key` or sub-array path. */
@@ -38,17 +42,35 @@ export declare class InlineTableComponent {
     /**
      * Optional business-logic transform applied after every cell edit — before emission.
      *
-     * Signature: `(changedKey, newValue, updatedRow) => transformedRow`
+     * Signature: `(changedKey, newValue, updatedRow, previousRow) => transformedRow`
      *
      * - `changedKey`: the `InlineColumnDef.key` of the edited column.
      * - `newValue`: the raw new value (string, number, or null).
      * - `updatedRow`: the row object already reflecting the edit.
+     * - `previousRow`: the row as it was before the edit — needed when the side-effect
+     *   depends on the replaced value (e.g. converting a quantity on a unit switch).
      * - Return the row (possibly further mutated) that should be stored.
      *
      * Use this for cross-field side-effects such as pre-populating nutrient % columns
      * when a product is selected.  For forms without such logic, omit this input.
      */
-    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>) | null>;
+    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>) | null>;
+    /**
+     * Optional per-cell validation resolver — returns a translated error message
+     * shown under the cell (cell turns red via `mat-form-field-invalid`), or `null`
+     * when valid. Inline tables bypass JSONForms/AJV, so business rules that must
+     * be visible while typing (e.g. percentage caps) are surfaced through this hook.
+     */
+    readonly cellError: import("@angular/core").InputSignal<InlineCellErrorResolver | null>;
+    /**
+     * Index of the row to visually highlight (e.g. after a validation-error deep-link).
+     * Also triggers a scrollIntoView so the row is on screen.
+     */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
+    /** Resolves the per-cell error message via the optional `cellError` input (null = valid). */
+    errorForCell(row: Record<string, unknown>, col: InlineColumnDef): string | null;
+    /** True when any column of the row reports an error — drives the row-level red tint. */
+    rowHasError(row: Record<string, unknown>): boolean;
     /** Extracts a px value from a grid-format width string (e.g. 'minmax(120px, 1fr)' → '120px'). */
     colMinWidth(width?: string): string;
     /** Total table width = sum of all column px values + 40px for the delete column. */
@@ -62,16 +84,25 @@ export declare class InlineTableComponent {
     readonly emptyHint: import("@angular/core").Signal<string>;
     /** Returns the option array for a select column from the shared CODE_LISTS map. */
     getOptions(col: InlineColumnDef): BaseCodeListEntry[];
+    /** Options for a select column, narrowed per row when the column defines `optionsFilter`. */
+    optionsForRow(col: InlineColumnDef, row: Record<string, unknown>): BaseCodeListEntry[];
+    /** Projects a select column's options into the searchable select's {value, label} shape. */
+    searchOptionsForRow(col: InlineColumnDef, row: Record<string, unknown>): SearchableSelectOption[];
+    /** Same projection for the subrows key selector (options are row-independent there). */
+    subrowSearchOptions(col: InlineColumnDef): SearchableSelectOption[];
     /**
      * Returns the localized display label for a code-list option.
+     * - `optionLabelKey`: translates the i18n key returned by the column's resolver — for
+     *   literal option lists whose labels live in the locales rather than in master data.
      * - `optionDisplay: 'id'`: returns `String(entry.id)` (e.g. "kg", "t").
-     * - default (`'label'`): uses `descriptor.designation_eng / designation_deu`;
+     * - default (`'label'`): uses the localized `descriptor.designation_<suffix>`;
      *   falls back to `String(entry.id)` when no descriptor is present.
      */
     optionLabel(entry: BaseCodeListEntry, col: InlineColumnDef): string;
     /**
      * Reads the current cell value for a column from a row object.
      *
+     * - `valueResolver` columns: fully derived value (e.g. from master data).
      * - Simple field: returns `row[col.key]`.
      * - Sub-array field: navigates `row[arrayPath]`, finds the entry matching
      *   `arrayKeyField === arrayKeyValue`, and returns `entry[arrayValueField]`.
@@ -92,10 +123,42 @@ export declare class InlineTableComponent {
     onNumberChange(rowIdx: number, col: InlineColumnDef, event: Event): void;
     /** Called on `(input)` of a text `<input>` (see onNumberChange for why not `(change)`). */
     onTextChange(rowIdx: number, col: InlineColumnDef, event: Event): void;
+    /** Called when a `mat-checkbox` is toggled. */
+    onCheckboxChange(rowIdx: number, col: InlineColumnDef, change: MatCheckboxChange): void;
+    /** Whether the cell widget is disabled for this row (per-row constraint hook). */
+    isCellDisabled(col: InlineColumnDef, row: Record<string, unknown>): boolean;
     /** Appends a blank row produced by `config.createRow()`. */
     addRow(): void;
     /** Removes the row at `idx` from the array. */
     removeRow(idx: number): void;
+    /** Ids of the expanded sub-rows panels, keyed `${rowIdx}:${col.key}` (UI-only state). */
+    private readonly expandedSubrows;
+    isSubrowsExpanded(rowIdx: number, col: InlineColumnDef): boolean;
+    toggleSubrows(rowIdx: number, col: InlineColumnDef): void;
+    /** Reads the nested key/value entries of a sub-rows column (never null). */
+    getSubEntries(row: Record<string, unknown>, col: InlineColumnDef): Record<string, unknown>[];
+    /** Options for the key select of a sub-rows column. */
+    getSubrowOptions(col: InlineColumnDef): BaseCodeListEntry[];
+    /** Localized label for a sub-entry key (descriptor designation, id as fallback). */
+    subrowKeyLabel(col: InlineColumnDef, keyValue: unknown): string;
+    /** Collapsed-cell summary, e.g. "Bovins 25 %, Porcs 75 %" ('–' when empty). */
+    subrowsSummary(row: Record<string, unknown>, col: InlineColumnDef): string;
+    /** Sum of the value fields of all sub-entries. */
+    subEntryTotal(row: Record<string, unknown>, col: InlineColumnDef): number;
+    /** Whether the sub-entry values sum to the configured expected total. */
+    subEntryTotalOk(row: Record<string, unknown>, col: InlineColumnDef): boolean;
+    addSubEntry(rowIdx: number, col: InlineColumnDef): void;
+    /** Moves focus to the key select of a freshly added sub-entry. setTimeout defers past
+     *  the parent's rows round-trip so the new sub-row exists in the DOM. */
+    private focusSubEntry;
+    removeSubEntry(rowIdx: number, col: InlineColumnDef, subIdx: number): void;
+    onSubEntryKeyChange(rowIdx: number, col: InlineColumnDef, subIdx: number, value: unknown): void;
+    /** Commits on every keystroke (not on blur) — same rationale as `onNumberChange`.
+     *  When `expectedTotal` is set, the value is clamped to the remaining share so the
+     *  sum can never exceed it; smaller intermediate keystrokes still go through. */
+    onSubEntryValueChange(rowIdx: number, col: InlineColumnDef, subIdx: number, event: Event): void;
+    /** Writes the sub-entry array back to the row, runs rowTransform, emits rowsChange. */
+    private updateSubEntries;
     /**
      * Core change handler: sets the new value on the row, applies the optional
      * `rowTransform` for any cross-field side-effects, then emits the updated array.

package/dist/types/app/components/inline-table/inline-table.types.d.ts

@@ -11,10 +11,58 @@
  * To reuse the table for a different domain, create a new config file and a thin
  * wrapper component.  Only the config changes; the rendering component stays the same.
  */
+import type { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
 /** Supported cell widget types. Extend with new literal types as needed.
  *  'readonly' renders the resolved value as plain text (no input) — for columns
- *  that are fully derived from other fields and must not be user-editable. */
-export type InlineCellType = 'select' | 'number' | 'text' | 'readonly';
+ *  that are fully derived from other fields and must not be user-editable.
+ *  'checkbox' renders a boolean mat-checkbox bound to a true/false row field.
+ *  'subrows' renders an expandable editor for a nested list of key/percentage
+ *  pairs (e.g. manureDerivation[]) — see `InlineSubrowsConfig`. */
+export type InlineCellType = 'select' | 'number' | 'text' | 'readonly' | 'checkbox' | 'subrows';
+/**
+ * Per-cell validation resolver — returns a translated error message to display
+ * under the cell, or `null` when the cell is valid. Passed as the `cellError`
+ * input of InlineTableComponent for domain tables that bypass JSONForms/AJV
+ * (inline tables are not schema-validated, so business rules like percentage
+ * caps must be surfaced visually through this hook).
+ */
+export type InlineCellErrorResolver = (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
+/**
+ * Configuration for a `type: 'subrows'` column — an expandable editor for a nested
+ * array of `{ key, value }` entries (e.g. manureDerivation: zoologicalAnimal +
+ * percentageAllocation). The collapsed cell shows a joined summary; expanding it
+ * opens a floating panel with one select + number input per entry, an add button,
+ * and a total indicator (green when the sum matches `expectedTotal`).
+ */
+export interface InlineSubrowsConfig {
+    /** Path to the nested array on the row object (e.g. `'manureDerivation'`). */
+    arrayPath: string;
+    /** Field holding the code-list key in each sub-entry (e.g. `'zoologicalAnimal'`). */
+    keyField: string;
+    /** Key into the shared `CODE_LISTS` map for the key select options. */
+    keyCodeListKey: string;
+    /** i18n key for the key sub-column header inside the panel. */
+    keyLabelKey: string;
+    /** Field holding the numeric share in each sub-entry (e.g. `'percentageAllocation'`). */
+    valueField: string;
+    /** i18n key for the value sub-column header inside the panel. */
+    valueLabelKey: string;
+    /** i18n key for the "add sub-entry" button label. */
+    addLabelKey: string;
+    /** i18n key for the expand toggle label (collapsed state). */
+    expandLabelKey: string;
+    /** i18n key for the collapse toggle label (expanded state). */
+    collapseLabelKey: string;
+    /** i18n key for the total indicator label. */
+    totalLabelKey: string;
+    /** Expected sum of the value fields (e.g. 100) — the indicator turns green on exact
+     *  match (no more, no less) and entered values are clamped so the sum never exceeds it. */
+    expectedTotal?: number;
+    /** Min for the value number input (default 0). */
+    valueMin?: number;
+    /** Max for the value number input (default: none). */
+    valueMax?: number;
+}
 /**
  * Definition for a single column in an inline table.
  *
@@ -47,16 +95,34 @@ export interface InlineColumnDef {
     /**
      * For `type: 'select'` — key into the shared `CODE_LISTS` map.
      * The generic component resolves the option list and their localized labels
-     * automatically via the `descriptor.designation_eng / designation_deu` convention.
+     * automatically via the localized `descriptor.designation_<suffix>` convention.
      */
     codeListKey?: string;
     /**
      * For `type: 'select'` — how to display an option's label in the dropdown.
-     * - `'label'` (default): use `descriptor.designation_eng/deu` — best for named products.
+     * - `'label'` (default): use the localized `descriptor.designation_<suffix>` — best for named products.
      * - `'id'`: use `String(entry.id)` verbatim — best for codes that are already
      *   human-readable (e.g. unit codes like "kg", "t", "l").
      */
     optionDisplay?: 'label' | 'id';
+    /**
+     * For `type: 'select'` — optional per-row narrowing of the code-list options,
+     * e.g. to restrict the product list based on another cell of the same row.
+     * Evaluated for every option of every row, so keep it cheap.
+     */
+    optionsFilter?: (entry: BaseCodeListEntry, row: Record<string, unknown>) => boolean;
+    /**
+     * For `type: 'select'` — resolve an option's label through an i18n key instead of the
+     * master-data descriptor (for literal option lists whose labels live in the locales,
+     * e.g. a row-type selector). Takes precedence over `optionDisplay`.
+     */
+    optionLabelKey?: (entry: BaseCodeListEntry) => string;
+    /**
+     * Optional i18n key for an explanatory tooltip shown via an info icon next to
+     * the column header (e.g. to explain a checkbox whose effect is not obvious).
+     * Omit for columns that need no extra explanation.
+     */
+    tooltipKey?: string;
     /**
      * CSS grid column-sizing token, e.g. `'minmax(140px, 2fr)'` or `'84px'`.
      * These values are joined to build the `grid-template-columns` style on the table.
@@ -72,6 +138,18 @@ export interface InlineColumnDef {
      * Defaults to `'any'` when omitted, allowing any decimal.
      */
     step?: string;
+    /**
+     * Custom cell-value resolver — takes precedence over the default read path.
+     * Use this for `type: 'readonly'` columns whose value is derived from master
+     * data or other cells (e.g. a standard yield looked up from the selected crop)
+     * and therefore does not live on the row object.
+     */
+    valueResolver?: (row: Record<string, unknown>) => unknown;
+    /**
+     * Per-row disabling of the cell widget (e.g. grey out the yield input when the
+     * selected crop does not permit yield input). Evaluated per row, keep it cheap.
+     */
+    disabledForRow?: (row: Record<string, unknown>) => boolean;
     /**
      * Sub-array navigation config — for columns whose value lives inside a nested array
      * on the row object (e.g. `ingredient[].quantity`).
@@ -92,6 +170,11 @@ export interface InlineColumnDef {
     arrayKeyField?: string;
     arrayKeyValue?: string;
     arrayValueField?: string;
+    /**
+     * Sub-rows editor config — required when `type: 'subrows'`, ignored otherwise.
+     * Drives the expandable key/percentage pair editor (see `InlineSubrowsConfig`).
+     */
+    subrows?: InlineSubrowsConfig;
 }
 /**
  * Full configuration for one inline-table instance — the "uischema" equivalent.

package/dist/types/app/components/suissebilanz-dashboard/suissebilanz-dashboard.component.d.ts

@@ -11,6 +11,8 @@ import { SuisseBilanzMetricsService } from './suissebilanz-metrics.service';
  */
 export declare class SuisseBilanzDashboardComponent {
     readonly embedded: import("@angular/core").InputSignal<boolean>;
+    /** Shows the official PDF download link even when `embedded` (header hidden). */
+    readonly showPdfButton: import("@angular/core").InputSignal<boolean>;
     protected readonly planning: PlanningBalanceService;
     private readonly sanitizer;
     protected readonly metricsService: SuisseBilanzMetricsService;

package/dist/types/app/core/i18n/i18n.service.d.ts

@@ -1,5 +1,7 @@
 import { PipeTransform, Signal } from '@angular/core';
 export type Locale = 'en' | 'de' | 'fr' | 'it';
+/** Suffix of master-data `descriptor` designation fields (e.g. `designation_fra`) for a locale. */
+export declare function designationSuffix(locale: Locale): 'deu' | 'eng' | 'fra' | 'ita';
 export type JsonFormsTranslator = (key: string, defaultMessage: string | undefined, context: unknown) => string;
 export declare class I18nService {
     private readonly _locale;
@@ -8,6 +10,7 @@ export declare class I18nService {
     readonly jsonFormsI18n: Signal<{
         locale: Locale;
         translate: JsonFormsTranslator;
+        translateError: (error: unknown, translate: JsonFormsTranslator) => string;
     }>;
     setLocale(locale: Locale): void;
     /** Returns true if the given string is a supported locale key. */

package/dist/types/app/core/navigation/navigation.service.d.ts

@@ -58,6 +58,11 @@ export declare class NavigationService {
         type: StorageEntryType;
         index: number;
     } | null>;
+    /** Selected field spreading row context (category/tab + row index) — used by validation deep-links */
+    readonly selectedFieldSpreadingDetail: import("@angular/core").WritableSignal<{
+        category: FieldSpreadingCategory;
+        index: number;
+    } | null>;
     /** True if currently viewing animal stock detail (not list) */
     readonly isAnimalStockDetailView: import("@angular/core").Signal<boolean>;
     /** True if currently on animal stock page (list or detail) */
@@ -81,6 +86,8 @@ export declare class NavigationService {
     navigateToFodderDetail(mode: FodderMode, index: number, category?: FodderCategory): void;
     navigateToFodderList(): void;
     navigateToFieldSpreading(category?: FieldSpreadingCategory): void;
+    /** Deep-link to a specific row of a field spreading tab (e.g. from a validation error). */
+    navigateToFieldSpreadingDetail(category: FieldSpreadingCategory, index: number): void;
     navigateToFieldCultivationDetail(tab: Exclude<FieldCultivationTab, 'general'>, index: number): void;
     navigateToFieldCultivationList(tab?: FieldCultivationTab): void;
     navigateToStorageDetail(type: StorageEntryType, index: number): void;

package/dist/types/app/core/planning/planning-balance.service.d.ts

@@ -33,6 +33,14 @@ export declare class PlanningBalanceService {
     };
     readonly selectedEndpoint: import("@angular/core").Signal<PlanningEndpoint>;
     setSelectedEndpoint(endpoint: PlanningEndpoint): void;
+    /**
+     * Builds the exact payload posted to the planning API: calculationVersion stamped from
+     * the current metadata, `nutrientCycle.generateReport` forced to true (the PDF report
+     * must always be requested on submission), empty ingredient/routine slots stripped,
+     * null optional fields and host-only fields removed, custom display units converted
+     * to base units.
+     */
+    buildApiPayload(data: NaebiData): NaebiData;
     /** Fire a new planning-balance request with the current NAEBI data payload. */
     runPlanning(data: NaebiData, endpoint?: PlanningEndpoint): void;
 }

package/dist/types/app/core/utils/custom-unit.util.d.ts

@@ -0,0 +1,39 @@
+export interface CustomUnit {
+    /** Unit code stored on the row (e.g. 'ha', 't', 'dt'). */
+    code: string;
+    /** API base unit this custom unit converts to (e.g. 'm2', 'kg'). */
+    baseUnit: string;
+    /** Multiplier from the custom unit to its base unit (1 ha = 10'000 m2 → 10000). */
+    factor: number;
+    descriptor?: Record<string, unknown>;
+}
+export declare const CUSTOM_UNITS: readonly CustomUnit[];
+/** True when the unit code is a custom display unit (not an API base unit). */
+export declare function isCustomUnit(unit: unknown): boolean;
+/** Base unit a quantity can be converted to: the custom unit's `baseUnit`, or the unit
+ *  itself when it already is a base (or unknown) unit. */
+export declare function baseUnitOf(unit: string | null | undefined): string | null | undefined;
+/** Custom units convertible to the given base unit (e.g. 'kg' → [t, dt]). */
+export declare function customUnitsForBaseUnit(baseUnit: string): CustomUnit[];
+/**
+ * Builds a filter (compatible with the inline table's `optionsFilter`) keeping only the
+ * units compatible with the given context base unit(s) — i.e. each base unit plus its
+ * custom units. Pass a nullable base (e.g. derived from a product's matterState): `null`
+ * keeps the full list (nothing derived yet); pass an array of bases (e.g. ['kg', 'm3'])
+ * to pre-filter to their union before the exact base is known.
+ *
+ * Works on any entry shape exposing `id` (and `baseUnit` for custom units).
+ */
+export declare function unitOptionsForBaseUnit<T extends {
+    id: string | number;
+}>(contextBaseUnit: string | readonly string[] | null | undefined): (entry: T) => boolean;
+/** Converts a quantity expressed in a custom unit to its base unit; pass-through for
+ *  base/unknown units and null quantities. */
+export declare function convertToBaseUnit(quantity: number | null | undefined, unit: string | null | undefined): {
+    quantity: number | null | undefined;
+    unit: string | null | undefined;
+};
+/** Converts a quantity between two units sharing the same base unit (kg ↔ t ↔ dt,
+ *  m2 ↔ ha). Returns the quantity unchanged when either unit is missing or the units
+ *  are incompatible (different base units). */
+export declare function convertQuantityBetween(quantity: number | null | undefined, fromUnit: string | null | undefined, toUnit: string | null | undefined): number | null | undefined;

package/dist/types/app/core/utils/object.util.d.ts

@@ -22,13 +22,25 @@ export declare function deepEqual(a: unknown, b: unknown): boolean;
  * @returns A deep copy of the value
  */
 export declare function deepClone<T>(value: T): T;
+export declare function stripIncompleteIngredients<T>(value: T): T;
 /**
- * Recursively drops `ingredient[]` entries whose `quantity` is null/undefined.
+ * Sanitizes the planning payload: the calculation API (OpenAPI, no `nullable: true`
+ * anywhere) accepts an optional field as *absent* but rejects it when present with a
+ * null value ("must be string/number"). The working data model normalizes optional
+ * fields to null, so strip them at the submission boundary — mirroring what
+ * `stripIncompleteIngredients` does for ingredient slots.
  *
- * Inline tables (fertiliser/recycling) pre-populate every nutrient slot in `ingredient[]`
- * so the UI always shows all formula columns, but slots the user never fills in stay as
- * `{ molecularFormula, quantity: null, unit }`. The calculation API rejects any ingredient
- * entry that's present but incomplete, so submitted payloads must omit those still-empty
- * slots entirely rather than send them with a null quantity.
+ * - inside `fieldCultivation` entry collections (fodderCropland, arableLand, special,
+ *   feedingOfCropHarvest, dispenseOfCropHarvest): any null property is dropped
+ *   (fieldName, userSpecificPlantName, yieldPerSquareMeasure, effectiveYield, …)
+ * - `nutrientCycle.fodder.trading.<collection>[].quantity`: null → dropped
+ * - `nutrientCycle.animalStock[].feeding.(winter|summer)Feeding`: never-filled routine
+ *   slots (`{}` rows pre-created by the inline tables) and null fields are dropped;
+ *   a season — and `feeding` itself — is removed when nothing filled-in remains
+ * - `nutrientCycle.fieldSpreading`: null fields dropped (`soilPh`, `slurry.*`,
+ *   `manure.*`); `slurry`/`manure` removed when nothing filled-in remains
  */
-export declare function stripIncompleteIngredients<T>(value: T): T;
+export declare function sanitizePlanningPayload(data: NaebiDataLike): NaebiDataLike;
+/** Structural type so object.util stays free of a NaebiData import (circular-safe). */
+type NaebiDataLike = Record<string, unknown>;
+export {};

package/dist/types/app/core/validation/ajv-custom.d.ts

@@ -9,6 +9,7 @@ import Ajv from 'ajv';
  *
  * Custom keywords:
  * - `permittedStableSystem`: Validates stable system against animal category constraints
+ * - `proportionSum`: Validates the sum of one numeric field across array items
  *
  * @param options - Additional AJV options to merge with defaults
  */

package/dist/types/app/core/validation/capabilities.d.ts

@@ -16,3 +16,9 @@ export declare function derivePermittedStableSystems(animalCategoryPRIF: number
  * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
  */
 export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;
+/**
+ * Pre-computed map of non-zero per-category minimum yields (yieldPerSquareMeasure).
+ * Only 8 of the 314 crop categories declare a minimum > 0 (e.g. cereals, peas);
+ * all others fall back to the schema-level `minimum: 0`.
+ */
+export declare const CROP_MINIMUM_YIELD_PER_SQUARE_MEASURE: Record<string, number>;