@asteby/metacore-runtime-react 28.3.6 → 28.4.1

package/src/dynamic-relations.tsx

@@ -11,6 +11,7 @@
 //     { owner_model: "Customer" }) into the panel's `filters` so the child list
 //     is scoped by the FK AND every scope column.
 import { useMemo } from 'react'
+import { cn } from '@asteby/metacore-ui/lib'
 import { DynamicRelation, type DynamicRelationStrings } from './dynamic-relation'
 import type { RelationMeta } from './types'
 
@@ -40,6 +41,14 @@ export interface DynamicRelationsProps {
     canEdit?: boolean
     /** Translatable strings forwarded to each DynamicRelation. */
     strings?: Partial<DynamicRelationStrings>
+    /**
+     * True cuando estos paneles se renderizan como sub-tablas de líneas dentro
+     * del MODAL de vista de un registro. Propaga `lineSubtable` a cada
+     * `<DynamicRelation>` para ocultar por defecto las columnas de auditoría/
+     * sistema redundantes bajo el padre. Default false — una página de detalle
+     * autónoma conserva todas las columnas.
+     */
+    lineSubtable?: boolean
     /** Bubble up when any panel's data changes (create/delete/attach/detach). */
     onChange?: (relation: RelationMeta) => void
 }
@@ -96,6 +105,7 @@ export function DynamicRelations({
     canDelete = true,
     canEdit = true,
     strings,
+    lineSubtable = false,
     onChange,
 }: DynamicRelationsProps) {
     const parentId = useMemo(
@@ -108,7 +118,10 @@ export function DynamicRelations({
     }
 
     return (
-        <div className={className} data-dynamic-relations="">
+        // `space-y-6` separates stacked relation panels (e.g. "Líneas del
+        // pedido" and "Facturas" in the view modal) — without it consecutive
+        // panels sat flush against each other with no breathing room.
+        <div className={cn('space-y-6', className)} data-dynamic-relations="">
             {relations.map((rel, idx) => {
                 const filters = buildRelationFilters(rel, parentId)
                 const panelStrings: Partial<DynamicRelationStrings> = {
@@ -135,6 +148,7 @@ export function DynamicRelations({
                             parentId={parentId}
                             filters={filters}
                             className={panelClassName}
+                            lineSubtable={lineSubtable}
                             canCreate={canCreate}
                             canDelete={canDelete}
                             readonly={relReadonly}
@@ -152,6 +166,7 @@ export function DynamicRelations({
                         parentId={parentId}
                         filters={filters}
                         className={panelClassName}
+                        lineSubtable={lineSubtable}
                         canCreate={canCreate}
                         canDelete={canDelete}
                         canEdit={canEdit}

package/src/index.ts

@@ -307,6 +307,8 @@ export {
     resolveDependsValue,
     getOptionsConfig,
     resolveOptionsSource,
+    getVisibleWhen,
+    evaluateVisibleWhen,
 } from './dynamic-form-schema'
 export {
     ActivityValueRenderer,

package/src/types.ts

@@ -295,6 +295,17 @@ export interface ColumnDefinition {
     itemFields?: ColumnItemField[]
     /** snake_case alias served by the kernel for `itemFields`. */
     item_fields?: ColumnItemField[]
+    /**
+     * Conditional visibility in the create/edit modal: render this field only
+     * when a sibling field's current value matches the predicate. Mirrors the
+     * kernel v3 `Column.visible_when` (projected onto the served ColumnDef).
+     * Tolerates the camelCase alias. Absent = always visible; a hidden field is
+     * skipped by the required-gate so it never blocks submit. See
+     * `evaluateVisibleWhen`.
+     */
+    visible_when?: VisibleWhen
+    /** camelCase alias for `visible_when`. */
+    visibleWhen?: VisibleWhen
 }
 
 /**
@@ -317,6 +328,21 @@ export interface ActionCondition {
     value: string | string[]
 }
 
+/**
+ * Conditional-visibility predicate for a create/edit form field. Mirrors the
+ * kernel v3 `visible_when` block (json `visible_when`): the owning field is
+ * rendered only when the SIBLING field named by `field` holds a value that
+ * matches — either equal to `equals` (exact string) OR a member of `in`
+ * (any-of). When both are set `in` wins. Absent = the field is always visible
+ * (retrocompat). Evaluated by `evaluateVisibleWhen` against the live form
+ * values; a hidden field never gates submit (its required-check is skipped).
+ */
+export interface VisibleWhen {
+    field: string
+    equals?: string
+    in?: string[]
+}
+
 // Mirrors `ValidationRule` from packages/sdk/src/generated/manifest.ts. Kept
 // inline here so runtime-react does not import generated kernel types directly
 // — apps and addons author ActionFieldDef literals.
@@ -493,6 +519,16 @@ export interface ActionFieldDef {
     storagePath?: string
     /** snake_case alias served by the kernel manifest for `storagePath`. */
     storage_path?: string
+    /**
+     * Conditional visibility: render this field only when a sibling field's
+     * current value matches the predicate. Mirrors the kernel v3
+     * `ActionField.visible_when`. Tolerates the camelCase alias. Absent = always
+     * visible; a hidden field is skipped by the required-gate so it never blocks
+     * submit. See `evaluateVisibleWhen`.
+     */
+    visible_when?: VisibleWhen
+    /** camelCase alias for `visible_when`. */
+    visibleWhen?: VisibleWhen
 }
 
 /**