@agridea/suibi-module 0.1.0-preview.b3c1d3c → 0.1.0-preview.c3246cc

package/dist/types/app/nutrient-cycle/field-cultivation/arable-land-table/arable-land-table.component.d.ts

@@ -15,7 +15,8 @@ export declare class ArableLandTableComponent {
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Crop change: clear yield + divergence when the new crop forbids yield input,
-     * so no stale values linger under the now-disabled cells.
+     * so no stale values linger under the now-disabled cells. Requirement corrections
+     * are special-crops-only (SUIBIL-1143): strip them so they never reach the emitted JSON.
      */
-    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation-master-detail/field-cultivation-master-detail.component.d.ts

@@ -12,7 +12,7 @@ export declare class FieldCultivationMasterDetailComponent {
     readonly feedingRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
     readonly dispenseRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
     readonly activeTab: import("@angular/core").WritableSignal<FieldCultivationTab>;
-    readonly activeTabIndex: import("@angular/core").Signal<0 | 1 | 2 | 3>;
+    readonly activeTabIndex: import("@angular/core").Signal<1 | 0 | 2 | 3>;
     onTabChange(index: number): void;
     onGeneralChange(value: FieldCultivationData): void;
     /** Persists one crop-harvest table's rows (fed / dispensed harvests of the general tab). */

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation.types.d.ts

@@ -11,8 +11,12 @@ export interface FieldCultivationCropHarvest {
 export interface FieldCultivationBaseEntry {
     agronomicCropCategory?: string | null;
     userSpecificPlantName?: string | null;
-    isMainCrop?: boolean;
+    /** Null for CSC_OUTVG special crops — the main-crop concept does not apply to them. */
+    isMainCrop?: boolean | null;
     areaSize?: number | null;
+    /** Host-only display unit for areaSize ('m2' base, or custom e.g. 'ha') — persisted in
+     *  the dossier, converted to m2 and stripped before the planning POST (docs/custom-units.md). */
+    areaUnit?: string | null;
     yieldPerSquareMeasure?: number | null;
 }
 export interface FieldCultivationFodderCropland extends FieldCultivationBaseEntry {

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation.util.d.ts

@@ -1,4 +1,8 @@
 import { FieldCultivationCropHarvest, FieldCultivationData, FieldCultivationDetailEntry, FieldCultivationDetailMode, FieldCultivationRequirementCorrection } from './field-cultivation.types';
+/** Subcategory whose special crops are never a main crop — `isMainCrop` must be null. */
+export declare const OUTDOOR_VEGETABLE_SUBCATEGORY = "CSC_OUTVG";
+/** True when the crop code belongs to the outdoor-vegetable subcategory (CSC_OUTVG). */
+export declare function isOutdoorVegetableCrop(cropCode: unknown): boolean;
 export declare function normalizeRequirementCorrection(source: Partial<FieldCultivationRequirementCorrection> | undefined): FieldCultivationRequirementCorrection;
 export declare function normalizeCropHarvestEntry(source: Partial<FieldCultivationCropHarvest> | undefined): FieldCultivationCropHarvest;
 export declare function normalizeFieldCultivationDetailEntry(mode: FieldCultivationDetailMode, source: Partial<FieldCultivationDetailEntry> | undefined): FieldCultivationDetailEntry;

package/dist/types/app/nutrient-cycle/field-cultivation/fodder-cropland-table/fodder-cropland-table.component.d.ts

@@ -21,7 +21,8 @@ export declare class FodderCroplandTableComponent {
     /**
      * Clears the yield whenever it stops being user-editable for the row (fodder-balance
      * calculation switched on, or new crop without yield input), so no stale value
-     * lingers under the now-disabled cell.
+     * lingers under the now-disabled cell. Requirement corrections are special-crops-only
+     * (SUIBIL-1143): strip them so they never reach the emitted JSON.
      */
-    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/special-crops-table/special-crops-table.component.d.ts

@@ -19,11 +19,11 @@ export declare class SpecialCropsTableComponent {
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Domain rules applied on every edit:
-     *  - units of the managed nutrient slots are fixed (N2 in kg, corrections in %),
+     *  - the unit of the managed nutrient slots is fixed (corrections in %),
      *  - managed slots left empty are dropped (the API rejects null quantities),
-     *  - selecting a crop pre-fills Nmin from its standard N2 requirement and resets the
-     *    corrections to 100 %; clearing the crop (or picking one that forbids corrections)
-     *    removes the managed slots.
+     *  - CSC_OUTVG crops carry `isMainCrop: null` (not a main-crop concept),
+     *  - selecting a crop pre-fills the three corrections (P2O5/K2O/Mg) at 100 %;
+     *    clearing the crop removes the managed slots.
      */
-    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/special-crops-table/special-crops-table.config.d.ts

@@ -4,14 +4,11 @@
  *
  * ONE table for the whole CULT_SPECIAL category: the crop dropdown reuses the
  * `agronomicCropCategorySpecial` code list, which is already filtered on
- * cultivationCategory === 'CULT_SPECIAL'. Nutrient columns live in the row's
- * `requirementCorrection[]` sub-array: Nmin is the N2 slot in kg, the three
- * corrections are the P2O5/K2O/Mg slots in %.
+ * cultivationCategory === 'CULT_SPECIAL'. The nutrient columns are the three
+ * corrections (P2O5/K2O/Mg slots in %) living in the row's
+ * `requirementCorrection[]` sub-array.
  */
 import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
-/** Nmin maps to the N2 requirement-correction slot, always expressed in kg. */
-export declare const NMIN_FORMULA = "N2";
-export declare const NMIN_UNIT = "kg";
 /** Correction slots managed by the table, always expressed in % (100 % = no correction). */
 export declare const CORRECTION_FORMULAS: readonly ["P2O5", "K2O", "Mg"];
 export declare const CORRECTION_UNIT = "%";
@@ -22,40 +19,33 @@ export declare const SPECIAL_CROPS_CODE_LIST = "agronomicCropCategorySpecial";
 export declare const SPECIAL_CROPS_IDS: Set<string>;
 /** Looks up a crop entry in the table's code list. */
 export declare function specialCropEntry(id: unknown): Record<string, unknown> | undefined;
+/** True when the row's crop belongs to the outdoor-vegetable subcategory (CSC_OUTVG). */
+export declare function isOutdoorVegetableRow(row: Record<string, unknown>): boolean;
 /**
- * Nutrient columns are read-only unless the selected crop has the
- * `isPermittedForRequirementCorrection` flag: without it, the pre-filled Nmin and
- * correction values are fixed defaults from master data and must not be user-editable.
+ * Enforces the isMainCrop rule: null for CSC_OUTVG crops (the main-crop concept does
+ * not apply), restored to false when switching back to a crop where the flag applies.
  */
-export declare function nutrientColumnsLocked(crop: Record<string, unknown> | undefined): boolean;
+export declare function normalizeIsMainCrop(row: Record<string, unknown>): Record<string, unknown>;
+/** Corrections (P2O5/K2O/Mg) apply to every special crop; locked only without a crop. */
+export declare function correctionColumnsLocked(crop: Record<string, unknown> | undefined): boolean;
 /**
- * Applies the crop's defaults to the requirement-correction slots.
- * - If the crop does NOT permit requirement corrections (or none is selected): the
- *   managed slots are removed entirely — nothing is editable and nothing is sent to the API.
- * - If the crop DOES permit them: the managed slots are pre-filled from the crop's
- *   master-data `requirement` (N2 in kg; P2O5/K2O/Mg in %) and stay user-editable.
+ * Applies the crop's defaults to the requirement-correction slots:
+ * - No crop selected: the managed slots are removed entirely — nothing is editable
+ *   and nothing is sent to the API.
+ * - Crop selected: the three corrections (P2O5/K2O/Mg) are reset to 100 % and
+ *   stay user-editable.
  */
 export declare function applyCropDefaults(row: Record<string, unknown>, crop: Record<string, unknown> | undefined): Record<string, unknown>;
 /**
- * Normalizes the managed requirement-correction slots on every edit: fixed units
- * (N2 → kg, corrections → %) and removal of managed entries left without a quantity
- * (the API rejects present-but-null quantities).
+ * Normalizes the managed requirement-correction slots on every edit: fixed unit
+ * (%) and removal of managed entries left without a quantity (the API rejects
+ * present-but-null quantities).
  */
 export declare function normalizeManagedCorrections(row: Record<string, unknown>): Record<string, unknown>;
 /**
- * Shared column definitions for the requirement-correction sub-array (Nmin + P2O5/K2O/Mg),
- * reusable across fodder, arable and special tables. `lockRow` disables editing per row.
+ * Shared column definitions for the requirement-correction sub-array (P2O5/K2O/Mg),
+ * reusable across fodder, arable and special tables. `lockCorrections` disables
+ * editing per row.
  */
-export declare function requirementCorrectionColumns(lockRow: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
-/**
- * Row-transform helper shared by fodder/arable: on every edit it normalizes the managed
- * slots and, if the selected crop does not permit requirement corrections, strips them
- * entirely (so nothing is sent to the API for those rows).
- */
-export declare function stripCorrectionsUnlessPermitted(row: Record<string, unknown>, codeListKey: string): Record<string, unknown>;
-/**
- * Row-transform helper shared by fodder/arable: on crop change it applies the crop's
- * master-data defaults (when permitted) or strips the managed slots (when not).
- */
-export declare function applyCropChangeRules(row: Record<string, unknown>, codeListKey: string): Record<string, unknown>;
+export declare function requirementCorrectionColumns(lockCorrections: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
 export declare const SPECIAL_CROPS_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-spreading/fertiliser-table/fertiliser-table.component.d.ts

@@ -1,3 +1,4 @@
+import { InlineColumnDef } from '../../../components/inline-table/inline-table.types';
 import { FieldSpreadingFertiliserEntry } from '../field-spreading.types';
 /**
  * FertiliserTableComponent — thin wrapper around InlineTableComponent.
@@ -17,8 +18,11 @@ import { FieldSpreadingFertiliserEntry } from '../field-spreading.types';
  *   3. The generic InlineTableComponent requires no changes.
  */
 export declare class FertiliserTableComponent {
+    private readonly i18n;
     readonly entries: import("@angular/core").InputSignal<FieldSpreadingFertiliserEntry[]>;
     readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldSpreadingFertiliserEntry[]>;
+    /** Row index to highlight after a validation-error deep-link (forwarded to the table). */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
     /** Column/section config exposed to the template (constant — no signal needed). */
     protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
     /** Cast typed entries to the generic Record[] expected by InlineTableComponent. */
@@ -29,15 +33,20 @@ export declare class FertiliserTableComponent {
     /**
      * Row transform for auto-populating nutrient columns when a product is selected.
      *
-     * Also imposes `transactionUnit = 'kg'` on every edit (not just product changes) so
-     * stale/imported rows with a different or null unit get corrected once touched —
-     * `createRow` already defaults new rows to 'kg', this is only a safety net.
+     * Unit handling: `transactionUnit` is user-selectable between kg and its custom units
+     * (t, dt). Switching the unit converts the already-entered quantity so the amount is
+     * preserved; legacy/imported rows without a unit default to kg.
      *
      * Defined as an arrow-function property so `this` is never needed and the function
      * can be passed as a value to InlineTableComponent without losing its context.
-     *
-     * Only reacts to changes on the `fertiliserProductCategory` column key; all other
-     * edits pass through unchanged.
      */
-    readonly autoPopulateNutrients: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly autoPopulateNutrients: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Per-cell validation for the nutrient % columns: each value capped at 100 %
+     * and the sum of the four ingredients capped at 100 % per row.
+     * The inline table bypasses JSONForms/AJV, so these rules (mirroring the
+     * `maximum` / `proportionSum` keywords in schema.json) must be surfaced
+     * visually here — the global validation panel alone is not visible while typing.
+     */
+    readonly nutrientCellError: (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
 }

package/dist/types/app/nutrient-cycle/field-spreading/field-spreading.component.d.ts

@@ -5,6 +5,8 @@ export declare class FieldSpreadingComponent {
     private readonly navigationSvc;
     private readonly i18n;
     constructor();
+    /** Fertiliser row to highlight (set by validation deep-links, cleared by the next one). */
+    readonly highlightedFertiliserIndex: import("@angular/core").WritableSignal<number | null>;
     readonly schema: import("@angular/core").Signal<JsonSchema>;
     readonly localizedGeneralUi: import("@angular/core").Signal<import("@jsonforms/core").UISchemaElement>;
     readonly renderers: {

package/dist/types/app/nutrient-cycle/field-spreading/field-spreading.types.d.ts

@@ -23,6 +23,7 @@ export interface FieldSpreadingIngredient {
     unit?: string | null;
 }
 export interface FieldSpreadingFertiliserEntry {
+    descriptor?: string | null;
     fertiliserProductCategory?: string | null;
     quantity?: number | null;
     transactionUnit?: string | null;

package/dist/types/app/nutrient-cycle/field-spreading/recycling-table/recycling-table.component.d.ts

@@ -6,10 +6,10 @@ import { FieldSpreadingRecyclingEntry } from '../field-spreading.types';
  *   1. Provides `RECYCLING_TABLE_CONFIG` (the column/section "uischema").
  *   2. Bridges typed `FieldSpreadingRecyclingEntry[]` to/from the generic
  *      `Record<string, unknown>[]` API of InlineTableComponent.
- *   3. Supplies `deriveUnits` as a `rowTransform` — `transactionUnit` ('kg'/'m3') and every
- *      ingredient's `unit` ('kg/t'/'kg/m3') are fully derived from the selected product's
- *      matterState (never user-entered) — they are separate mappings, NOT a concatenation of
- *      one into the other (kg/kg would be wrong for solid products).
+ *   3. Supplies `deriveUnits` as a `rowTransform` — the base `transactionUnit` ('kg'/'m3')
+ *      and every ingredient's `unit` ('kg/t'/'kg/m3') are derived from the selected
+ *      product's matterState; the user may switch to a custom unit sharing the same base
+ *      (t, dt for kg), which converts the entered quantity on the fly.
  */
 export declare class RecyclingTableComponent {
     readonly entries: import("@angular/core").InputSignal<FieldSpreadingRecyclingEntry[]>;
@@ -22,10 +22,11 @@ export declare class RecyclingTableComponent {
      *  ingredient with a 0 quantity so it never reaches the final JSON. */
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
-     * Row transform re-deriving `transactionUnit` and every ingredient's `unit` from the
-     * product's matterState on each edit — runs unconditionally (not just when
-     * `typeOfManureRecyclingProduct` changes) so an edit made before the product is picked still
-     * resolves once it is.
+     * Row transform deriving the ingredient units from the product's matterState on each
+     * edit, and handling `transactionUnit`:
+     *  - product change (or missing unit on legacy rows): reset to the derived base unit,
+     *  - unit switch: convert the entered quantity from the previous to the new unit
+     *    (both share the same base), so the transacted amount is preserved.
      */
-    readonly deriveUnits: (_changedKey: string, _newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly deriveUnits: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/fodder/fodder-table/fodder-table.component.d.ts

@@ -19,8 +19,10 @@ export declare class FodderTableComponent {
      *    when it is not permitted for the new kind.
      *  - Product change: pre-fill the dry matter share (T/S %) with the product's
      *    `standardDryMatterContent` (stays editable afterwards; null when none is defined).
-     *  - Units are fixed, never user-entered: quantity is always transacted in kg and the only
-     *    permitted ingredient is dry matter (T/S) expressed in % — re-appended when missing.
+     *  - `transactionUnit` is selectable between kg and its custom units (t, dt): switching
+     *    converts the entered quantity so the amount is preserved; rows without a unit
+     *    default to kg. The only permitted ingredient is dry matter (T/S) in % — re-appended
+     *    when missing.
      */
-    readonly enforceFodderRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceFodderRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agridea/suibi-module",
-  "version": "0.1.0-preview.b3c1d3c",
+  "version": "0.1.0-preview.c3246cc",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",