@agridea/suibi-module 0.1.0-preview.01100f9 → 0.1.0-preview.0808fe0

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.01100f9",
+  "version": "0.1.0-preview.0808fe0",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",