feat(spa): map every form-spec widget.kind + route strings through i18n (#664, #669)

#664: adaptFormSpec now maps all 23 WidgetKind values onto an exhaustive
Record<WidgetKind, WidgetHint|undefined> (a new kind is a compile error).
FieldInput renders hidden as a real hidden input, split-datetime as date+time,
select-date as a date input, checkbox-multiple/select-multiple as a checkbox
bank / <select multiple>, autocomplete(-multiple), and file (limited control +
legacy-admin note, upload tracked by #241). Kinds with no faithful control map
to an explicit operator-visible unsupported_widget tracked fallback — never a
silent wrong control. The test asserts every enum member maps sensibly.

#669: FieldInput's Lookup ↗ / lookup aria-label, — select — / (none), and the
time/array/range/FK placeholders now go through t(); new keys added to the
es/fr/pt catalogs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: martin-castro-laminr-ai

frontend/apps/web/src/pages/detail/adaptFormSpec.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest';
 
-import type { DetailResponse, FormSpecField, FormSpecResponse } from '@dar/data';
+import type {
+  DetailResponse,
+  FormSpecField,
+  FormSpecResponse,
+  WidgetHint,
+  WidgetKind,
+} from '@dar/data';
 
 import { detailFromFormSpec, formSpecFieldToDescriptor } from './adaptFormSpec';
 
@@ -26,12 +32,94 @@ describe('formSpecFieldToDescriptor (#659)', () => {
     expect(formSpecFieldToDescriptor(fsField({ widget: { kind: 'shuttle', attrs: {} } })).widget).toBe('shuttle_h');
   });
 
-  it('leaves widget undefined for kinds the FieldType already implies (select/date/autocomplete/…)', () => {
+  it('leaves widget undefined for kinds the FieldType already implies (select/date/…)', () => {
     expect(formSpecFieldToDescriptor(fsField({ widget: { kind: 'select', attrs: {} } })).widget).toBeUndefined();
     expect(formSpecFieldToDescriptor(fsField({ widget: { kind: 'date', attrs: {} } })).widget).toBeUndefined();
-    expect(
-      formSpecFieldToDescriptor(fsField({ widget: { kind: 'autocomplete', attrs: {} } })).widget,
-    ).toBeUndefined();
+    expect(formSpecFieldToDescriptor(fsField({ widget: { kind: 'text', attrs: {} } })).widget).toBeUndefined();
+    expect(formSpecFieldToDescriptor(fsField({ widget: { kind: 'number', attrs: {} } })).widget).toBeUndefined();
+  });
+
+  it('maps the kinds that need a control FieldType would NOT pick (#664)', () => {
+    const hintFor = (kind: WidgetKind): WidgetHint | undefined =>
+      formSpecFieldToDescriptor(fsField({ widget: { kind, attrs: {} } })).widget;
+    expect(hintFor('hidden')).toBe('hidden');
+    expect(hintFor('split-datetime')).toBe('split_datetime');
+    expect(hintFor('select-date')).toBe('select_date');
+    expect(hintFor('checkbox-multiple')).toBe('checkbox_multiple');
+    expect(hintFor('select-multiple')).toBe('select_multiple');
+    expect(hintFor('autocomplete')).toBe('autocomplete');
+    expect(hintFor('autocomplete-multiple')).toBe('autocomplete_multiple');
+    expect(hintFor('file')).toBe('file');
+  });
+
+  it('maps EVERY declared WidgetKind to something sensible — no silent no-op (#664)', () => {
+    // The full closed enum from the contract. If a kind is added to the
+    // wire without a mapping, this list (and the exhaustive `KIND_TO_HINT`
+    // record) must be updated — keeping the SPA honest about every kind.
+    const ALL_KINDS: WidgetKind[] = [
+      'text',
+      'textarea',
+      'number',
+      'email',
+      'url',
+      'password',
+      'hidden',
+      'checkbox',
+      'checkbox-multiple',
+      'select',
+      'select-multiple',
+      'radio',
+      'date',
+      'datetime',
+      'time',
+      'split-datetime',
+      'select-date',
+      'file',
+      'autocomplete',
+      'autocomplete-multiple',
+      'raw-id',
+      'shuttle',
+      'custom',
+    ];
+    // Kinds whose FieldType-derived control is already faithful → no hint.
+    const NO_HINT = new Set<WidgetKind>([
+      'text',
+      'textarea',
+      'number',
+      'email',
+      'url',
+      'checkbox',
+      'select',
+      'date',
+      'datetime',
+      'time',
+    ]);
+    const VALID_HINTS = new Set<WidgetHint>([
+      'radio',
+      'raw_id',
+      'password',
+      'shuttle_h',
+      'shuttle_v',
+      'custom',
+      'hidden',
+      'split_datetime',
+      'select_date',
+      'checkbox_multiple',
+      'select_multiple',
+      'autocomplete',
+      'autocomplete_multiple',
+      'file',
+      'unsupported_widget',
+    ]);
+    for (const kind of ALL_KINDS) {
+      const hint = formSpecFieldToDescriptor(fsField({ widget: { kind, attrs: {} } })).widget;
+      if (NO_HINT.has(kind)) {
+        expect(hint, `${kind} should defer to FieldType`).toBeUndefined();
+      } else {
+        expect(hint, `${kind} must map to a real WidgetHint`).toBeDefined();
+        expect(VALID_HINTS.has(hint as WidgetHint), `${kind} → ${hint}`).toBe(true);
+      }
+    }
   });
 
   it('passes the custom widget_class through so the SPA can dispatch a registered renderer', () => {

frontend/apps/web/src/pages/detail/adaptFormSpec.ts

@@ -18,12 +18,34 @@ import type {
   WidgetHint,
 } from '@dar/data';
 
-// The closed `widget.kind` enum → the SPA's existing `WidgetHint` controls.
-// Kinds with no dedicated hint (select, checkbox, date, file, autocomplete,
-// …) return undefined: FieldInput then renders the control implied by
-// `FieldType`, which already covers them (a select for `choice`, an
-// AutocompleteInput for an FK with a `to` target, etc.).
-const KIND_TO_HINT: Partial<Record<WidgetKind, WidgetHint>> = {
+// The closed `widget.kind` enum → the SPA's `WidgetHint` controls (#664).
+//
+// EVERY one of the 23 declared `WidgetKind` values is mapped explicitly so
+// no kind silently degrades to a wrong control:
+//   • `undefined` — the control `FieldType` already implies is faithful
+//     (e.g. `text` → text input, `select` → <select>, `date` → date input,
+//     `datetime` → datetime-local, `time` → time input, `checkbox` →
+//     boolean checkbox, `number` → number input, `email`/`url` → typed
+//     inputs). Listed here on purpose so adding a kind is a compile error
+//     until it's classified (the test asserts the record is exhaustive).
+//   • a real hint — a kind that needs a control `FieldType` would NOT pick
+//     (hidden, split-datetime, the multi-selects, autocomplete, file, …).
+// There is no implicit fallback: an unmapped kind would be a `undefined`
+// type error, and a kind we can't render faithfully maps to the explicit,
+// operator-visible `unsupported_widget` tracked fallback in FieldInput.
+const KIND_TO_HINT: Record<WidgetKind, WidgetHint | undefined> = {
+  // Kinds whose FieldType-derived control is already faithful.
+  text: undefined,
+  textarea: undefined,
+  number: undefined,
+  email: undefined,
+  url: undefined,
+  checkbox: undefined,
+  select: undefined,
+  date: undefined,
+  datetime: undefined,
+  time: undefined,
+  // Security / parity hints that were already wired.
   password: 'password',
   radio: 'radio',
   'raw-id': 'raw_id',
@@ -32,6 +54,15 @@ const KIND_TO_HINT: Partial<Record<WidgetKind, WidgetHint>> = {
   // ShuttleSelect supports both and the difference is purely visual).
   shuttle: 'shuttle_h',
   custom: 'custom',
+  // Kinds that need a control FieldType alone would render WRONGLY (#664).
+  hidden: 'hidden',
+  'split-datetime': 'split_datetime',
+  'select-date': 'select_date',
+  'checkbox-multiple': 'checkbox_multiple',
+  'select-multiple': 'select_multiple',
+  autocomplete: 'autocomplete',
+  'autocomplete-multiple': 'autocomplete_multiple',
+  file: 'file',
 };
 
 function maxLengthFrom(field: FormSpecField): number | undefined {

frontend/packages/api/src/contract.ts

@@ -48,14 +48,38 @@ export type FieldType =
  * widget via `registerFieldWidget(widget_class, …)` (#625); falls back
  * to the default control + an "open in legacy admin" note when no
  * registration matches.
+ *
+ * The remaining hints map the form-spec `widget.kind` values that need a
+ * different control than `FieldType` alone implies (#664):
+ * `hidden` (render a real hidden input, never a visible field);
+ * `split_datetime` (`SplitDateTimeWidget` — two controls: date + time);
+ * `select_date` (`SelectDateWidget` — month / day / year selects);
+ * `checkbox_multiple` (a checkbox bank) / `select_multiple` (a native
+ * `<select multiple>`) for non-relational multi-value choice fields;
+ * `autocomplete` / `autocomplete_multiple` (`autocomplete_fields` typeahead);
+ * `file` (a file input — upload itself is tracked under #241, so this is a
+ * deliberately limited control with an operator note);
+ * `unsupported_widget` is the explicit tracked-fallback for any kind with
+ * no faithful control yet — it renders the default control plus a visible
+ * operator note (mirroring the `custom`-unregistered branch) so a gap is
+ * never a silent wrong control.
  */
 export type WidgetHint =
   | 'radio'
   | 'raw_id'
   | 'password'
   | 'shuttle_h'
   | 'shuttle_v'
-  | 'custom';
+  | 'custom'
+  | 'hidden'
+  | 'split_datetime'
+  | 'select_date'
+  | 'checkbox_multiple'
+  | 'select_multiple'
+  | 'autocomplete'
+  | 'autocomplete_multiple'
+  | 'file'
+  | 'unsupported_widget';
 
 export interface Permissions {
   view: boolean;
@@ -405,6 +429,17 @@ export interface ListResponse {
   pk_field: string;
   permissions: Permissions;
   columns: ColumnDescriptor[];
+  /**
+   * `ModelAdmin.list_display_links` (#251 / #666): the column name(s) whose
+   * cell links to the change page. The backend resolves
+   * `get_list_display_links` (which defaults to the first column) and emits
+   * the result; an empty array means `list_display_links = None` — *no*
+   * column links and the rows are not clickable. Only string column names
+   * round-trip (callable `list_display` entries are dropped backend-side).
+   * Optional for back-compat with a pre-1.6.0 backend: when absent the SPA
+   * falls back to linking the first non-pk column (legacy behaviour).
+   */
+  list_display_links?: string[];
   search_fields: string[];
   /** `ModelAdmin.search_help_text` — shown under the search box (#445).
    *  Empty string when unset. */
@@ -720,6 +755,15 @@ export interface FormSpecResponse {
   /** Dotted path of the resolved `Form` class — changes when a
    *  request-aware `get_form` switched form by querystring/user. */
   variant: string;
+  /**
+   * `ModelAdmin.prepopulated_fields` as `{target: [sources]}` (#245 / #664).
+   * Emitted by the form-spec endpoint only on the ADD form (rest-api 1.6.0+),
+   * matching Django's slugify-on-keystroke behaviour for a *new* object. The
+   * SPA slugifies the target from its sources as the user types, until the
+   * target is hand-edited. Restricted backend-side to rendered, non-readonly
+   * targets. Optional/absent on the change form and on a pre-1.6.0 backend.
+   */
+  prepopulated_fields?: Record<string, string[]>;
 }
 
 /** Escape hatch: embed the legacy admin change/add page in an iframe. */