@asteby/metacore-runtime-react 49.2.1 → 49.3.1

package/src/business/document-editor.tsx

@@ -48,6 +48,8 @@ import {
     splitEditorFields,
     toOpenDocuments,
     friendlyOptionLabel,
+    gatedOptionFixes,
+    gatedOptions,
     withFriendlyOptions,
     type EditorIssue,
     type SeedLabel,
@@ -215,6 +217,15 @@ export function DocumentEditor({
     const fieldKeys = useRef<string[]>([])
     fieldKeys.current = allFields.map((f) => f.key)
 
+    // Opciones condicionadas (`options[].when`): al cambiar el campo del que
+    // dependen —a mano, por la contraparte o por «Cargar desde…»— el valor que
+    // dejó de aplicar se ajusta solo (método PPD → forma de pago 99) y viaja así
+    // en el alta, no solo en el diálogo de timbrado.
+    useEffect(() => {
+        const fixes = gatedOptionFixes(allFields, header)
+        if (Object.keys(fixes).length > 0) setHeader((h) => ({ ...h, ...gatedOptionFixes(allFields, h) }))
+    }, [allFields, header])
+
     // Contraparte: tarjeta + defaults de las extensiones con la misma clave.
     const partyId = type.party ? header[type.party.field] : undefined
     useEffect(() => {
@@ -435,11 +446,11 @@ export function DocumentEditor({
                     setSourceNote(
                         loaded.length === 0 && covered > 0
                             ? t('documentEditor.source_all_covered', {
-                                  defaultValue: 'Todo el documento ya está registrado en otros documentos; no queda nada pendiente.',
+                                  defaultValue: 'Ese documento ya se registró completo; no queda nada pendiente.',
                               })
                             : covered > 0
                               ? t('documentEditor.source_loaded_partial', {
-                                    defaultValue: '{{count}} renglones con lo pendiente · {{covered}} ya cubiertos se omitieron',
+                                    defaultValue: '{{count}} renglones con lo que falta · {{covered}} ya completos (omitidos)',
                                     count: loaded.length,
                                     covered,
                                 })
@@ -579,7 +590,7 @@ export function DocumentEditor({
                 <FieldLabel htmlFor={field.key} required={field.required}>
                     {tl(field.label)}
                 </FieldLabel>
-                {renderField(withFriendlyOptions(field), header[field.key], (v: any) => updateField(field.key, v), header, fieldRecord, fieldErrors)}
+                {renderField(withFriendlyOptions(gatedOptions(field, header)), header[field.key], (v: any) => updateField(field.key, v), header, fieldRecord, fieldErrors)}
                 {fieldErrors[field.key] && <p className="mt-1 text-xs text-destructive">{fieldErrors[field.key]}</p>}
             </FieldCell>
         ) : null
@@ -654,7 +665,7 @@ export function DocumentEditor({
                 {sources.length > 1 && (
                     <div
                         role="radiogroup"
-                        aria-label={t('documentEditor.source_kind', { defaultValue: 'Tipo de documento origen' })}
+                        aria-label={t('documentEditor.source_kind', { defaultValue: 'Documento de origen' })}
                         className="inline-flex flex-wrap gap-1 rounded-md border p-1"
                     >
                         {sources.map((s) => (

package/src/document-form-dialog.tsx

@@ -211,17 +211,26 @@ export function DocumentFormDialog({
     )
     const lineCfg = type ? editorLinesConfig(type, forms) : undefined
 
-    // Reset every time the dialog (re)opens.
-    useEffect(() => {
-        if (!open) return
-        const start = initialType ?? single?.key ?? null
-        setTypeKey(start)
-        setStep(start ? 'fields' : 'type')
-        setLines([])
-        setFieldErrors({})
-        setServerLineErrors({})
-        setFormError(undefined)
-    }, [open, initialType, single?.key])
+    // Reset every time the dialog (re)opens — DURING render, not in an effect.
+    // The host keeps this dialog mounted while closed (and across views whose
+    // forms change, e.g. the same /m/$model route going Facturas → Notas de
+    // crédito); an effect reset ran after the first open frame was already
+    // painted with the previous type/step, so the wizard (or the previous
+    // type's editor) flashed before the right DocumentEditor (QA Pitsline r6).
+    const openKey = open ? `${initialType ?? ''}\u0000${single?.key ?? ''}` : null
+    const [resetFor, setResetFor] = useState<string | null>(null)
+    if (openKey !== resetFor) {
+        setResetFor(openKey)
+        if (openKey !== null) {
+            const start = initialType ?? single?.key ?? null
+            setTypeKey(start)
+            setStep(start ? 'fields' : 'type')
+            setLines([])
+            setFieldErrors({})
+            setServerLineErrors({})
+            setFormError(undefined)
+        }
+    }
 
     // Seed field defaults for the chosen type.
     useEffect(() => {

package/src/dynamic-form-schema.ts

@@ -4,8 +4,13 @@
 import { z, type ZodTypeAny } from 'zod'
 import type { ActionFieldDef, FieldOptionsConfig, OptionDef, VisibleWhen } from './types'
 import { fieldValidationOf } from './validator'
+import { applyOptionWhen, getDependsOn } from './option-when'
 import { resolveValidatorToken } from './use-org-config-bridge'
 
+// Viven en option-when.ts (el validador también los usa); se re-exportan aquí
+// para no romper a quien los importaba de este módulo.
+export { applyOptionWhen, getDependsOn }
+
 /**
  * Built-in validators the SDK knows how to apply by symbolic name. Apps
  * that wire `OrgConfigProvider` map `$org.<key>` references to one of
@@ -389,18 +394,6 @@ export function fieldHasRef(field: ActionFieldDef): boolean {
     return getFieldRef(field) !== undefined
 }
 
-/**
- * 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
-}
 
 /**
  * Resolves the cascade `filter_value` for a field from the surrounding form
@@ -424,49 +417,6 @@ export function resolveDependsValue(
     return String(raw)
 }
 
-/**
- * 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
-    })
-}
-
 /**
  * Reads a field's `visible_when` predicate, tolerating the camelCase alias
  * (`visibleWhen`) an app may author and the snake_case (`visible_when`) the

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
     }
 }