@asteby/metacore-runtime-react 49.2.0 → 49.3.0

package/src/dynamic-row-actions.tsx

@@ -44,12 +44,20 @@ import type { TableMetadata, ActionMetadata, RequiresAddon } from './types'
  * Destino de una acción link. La query (`?create=…&from_id=…`) va como `search`:
  * metida en `to` el router la tomaba como parte del path y la ruta no casaba.
  */
-export function linkNavigation(url: string): { to: string; search?: Record<string, string> } {
+export function linkNavigation(
+    url: string,
+): { to: '/m/$model'; params: { model: string }; search?: Record<string, string> } | { to: string; search?: Record<string, string> } {
     const i = url.indexOf('?')
-    if (i < 0) return { to: url }
-    return { to: url.slice(0, i), search: Object.fromEntries(new URLSearchParams(url.slice(i + 1))) }
+    const path = i < 0 ? url : url.slice(0, i)
+    const search = i < 0 ? undefined : Object.fromEntries(new URLSearchParams(url.slice(i + 1)))
+    // /m/<tabla>?create=&from=&from_id= → ruta parametrizada (retest r6b: el menú
+    // «Nota de crédito» de la factura aterrizaba en la lista sin abrir el editor).
+    const m = path.match(/^\/m\/([^/?#]+)\/?$/)
+    if (m) return { to: '/m/$model', params: { model: m[1] }, search }
+    return search ? { to: path, search } : { to: path }
 }
 
+
 export interface UseDynamicRowActionsParams {
     /** Model key as registered on the backend (e.g. "issue"). */
     model: string
@@ -138,7 +146,7 @@ export function useDynamicRowActions({
         }
         const linkDef = metadata?.actions?.find((a) => a.key === action && a.type === 'link')
         if (linkDef?.linkUrl) {
-            const url = linkDef.linkUrl.replace(/\{(\w+)\}/g, (_: string, field: string) => encodeURIComponent(String(row[field] ?? '')))
+            const url = linkDef.linkUrl.replace(/\{(\w+)\}/g, (_: string, field: string) => String(row[field] ?? ''))
             navigate(linkNavigation(url) as any)
             return
         }

package/src/option-when.ts

@@ -0,0 +1,61 @@
+// option-when.ts — opciones estáticas de un select condicionadas por el valor
+// de un campo hermano (`options[].when`) y la dependencia declarada del campo
+// (`dependsOn`). Módulo hoja: lo usan el formulario (dynamic-form-schema), el
+// render compartido de campos (renderField) y el validador, sin ciclos.
+import type { ActionFieldDef, OptionDef } from './types'
+
+/**
+ * Resolves a field's cascade dependency — the key of another form field whose
+ * current value scopes this picker's options (`filter_value`). Tolerates the
+ * camelCase `dependsOn` (authored SDK shape) and the snake_case `depends_on`
+ * the kernel manifest serves. Returns the trimmed field key, or `undefined`
+ * when the field declares no dependency.
+ */
+export function getDependsOn(field: ActionFieldDef): string | undefined {
+    const dep = field.dependsOn ?? field.depends_on
+    if (typeof dep === 'string' && dep.trim() !== '') return dep.trim()
+    return undefined
+}
+
+/**
+ * Filters a STATIC enum's `options[]` by each option's `when` gate against the
+ * current form values. Pure — no React, no side effects.
+ *
+ * Rule per option:
+ * - No `when` → always included (retrocompat; existing enums untouched).
+ * - With `when`: the gating field is `when.field ?? dependsOn`. If neither is
+ *   present the option is included (nothing to gate on). Otherwise the form's
+ *   value for that field is compared AS STRING: included when (no `in`, or
+ *   value ∈ `in`) AND (no `not_in`, or value ∉ `not_in`). Tolerates the
+ *   snake_case `not_in` the kernel serves alongside camelCase `notIn`.
+ *
+ * `formValues` is the flat map of the surrounding form/row values the gating
+ * field is read from; `dependsOn` is the containing field's declared dependency
+ * used as the default gating field.
+ */
+export function applyOptionWhen(
+    options: OptionDef[] | undefined,
+    formValues: Record<string, any> | null | undefined,
+    dependsOn?: string,
+): OptionDef[] {
+    if (!Array.isArray(options)) return []
+    return options.filter((opt) => {
+        const when = opt?.when
+        if (!when) return true
+        const gate = (typeof when.field === 'string' && when.field.trim() !== '')
+            ? when.field.trim()
+            : dependsOn
+        if (!gate) return true
+        const raw = formValues ? formValues[gate] : undefined
+        const current = raw == null ? '' : String(raw)
+        const inList = when.in
+        const notIn = when.notIn ?? when.not_in
+        if (Array.isArray(inList) && inList.length > 0) {
+            if (!inList.some((v) => String(v) === current)) return false
+        }
+        if (Array.isArray(notIn) && notIn.length > 0) {
+            if (notIn.some((v) => String(v) === current)) return false
+        }
+        return true
+    })
+}

package/src/validator.ts

@@ -4,6 +4,7 @@
 // the same keys.
 import type { ActionFieldDef, FieldValidation } from './types'
 import type { FieldIssue } from './server-error'
+import { applyOptionWhen, getDependsOn } from './option-when'
 
 const NIL_UUID = '00000000-0000-0000-0000-000000000000'
 const NUMERIC_TYPES = new Set(['int', 'integer', 'bigint', 'decimal', 'numeric', 'number', 'float', 'double'])
@@ -207,7 +208,13 @@ function checkBuiltin(slug: string, value: unknown): FieldIssue | undefined {
     }
 }
 
-function specFromField(field: ActionFieldDef): ValidationSpec {
+/**
+ * `context` son los valores hermanos contra los que se evalúa el `when` de
+ * cada opción: una opción que su `when` descarta con el valor actual (forma de
+ * pago «99» con método PUE) es `invalid_option`, igual que una fuera de catálogo
+ * — y como la rechaza el kernel al guardar.
+ */
+function specFromField(field: ActionFieldDef, context?: Record<string, unknown>): ValidationSpec {
     const v = fieldValidationOf(field)
     const spec: ValidationSpec = {
         required: !!field.required,
@@ -217,7 +224,10 @@ function specFromField(field: ActionFieldDef): ValidationSpec {
         max: v.max,
         custom: v.custom,
     }
-    if (field.options?.length) spec.options = field.options.map(o => String(o.value))
+    if (field.options?.length) {
+        const applicable = context ? applyOptionWhen(field.options, context, getDependsOn(field)) : field.options
+        spec.options = applicable.map(o => String(o.value))
+    }
     return spec
 }
 
@@ -238,7 +248,7 @@ export function validateValues(
     values: Record<string, unknown>,
 ): Record<string, FieldIssue[]> {
     const bag: Record<string, FieldIssue[]> = {}
-    walk(fields, values ?? {}, '', bag)
+    walk(fields, values ?? {}, '', bag, values ?? {})
     return bag
 }
 
@@ -247,6 +257,7 @@ function walk(
     values: Record<string, unknown>,
     prefix: string,
     bag: Record<string, FieldIssue[]>,
+    context: Record<string, unknown>,
 ): void {
     for (const field of fields) {
         const key = field.key
@@ -261,11 +272,12 @@ function walk(
             }
             rows.forEach((row, i) => {
                 const obj = row && typeof row === 'object' ? (row as Record<string, unknown>) : {}
-                walk(itemFieldsOf(field), obj, `${path}.${i}`, bag)
+                // Una celda puede depender de otra del renglón o del encabezado.
+                walk(itemFieldsOf(field), obj, `${path}.${i}`, bag, { ...context, ...obj })
             })
             continue
         }
-        const issues = checkValue(raw, specFromField(field))
+        const issues = checkValue(raw, specFromField(field, context))
         if (issues.length) bag[path] = issues
     }
 }