@asteby/metacore-runtime-react 28.3.7 → 28.5.0

package/src/dynamic-form-schema.ts

@@ -2,7 +2,7 @@
 // callers (and unit tests) can use the zod schema without pulling in React or
 // metacore-ui primitives.
 import { z, type ZodTypeAny } from 'zod'
-import type { ActionFieldDef, FieldValidation, FieldOptionsConfig, OptionDef } from './types'
+import type { ActionFieldDef, FieldValidation, FieldOptionsConfig, OptionDef, VisibleWhen } from './types'
 import { resolveValidatorToken } from './use-org-config-bridge'
 
 /**
@@ -335,6 +335,52 @@ export function applyOptionWhen(
     })
 }
 
+/**
+ * Reads a field's `visible_when` predicate, tolerating the camelCase alias
+ * (`visibleWhen`) an app may author and the snake_case (`visible_when`) the
+ * kernel serves. Returns `undefined` when the field declares neither.
+ */
+export function getVisibleWhen(
+    field: { visible_when?: VisibleWhen; visibleWhen?: VisibleWhen } | null | undefined,
+): VisibleWhen | undefined {
+    if (!field) return undefined
+    const vw = field.visible_when ?? field.visibleWhen
+    return vw && typeof vw === 'object' && typeof vw.field === 'string' ? vw : undefined
+}
+
+/**
+ * Evaluates a `visible_when` predicate against the current flat form values.
+ * Pure — no React, no side effects.
+ *
+ * - No predicate → `true` (the field is always visible; retrocompat).
+ * - With a predicate: read the value of the sibling `cond.field` from
+ *   `formValues` (as string, null/undefined → ''). Visible when it is a member
+ *   of `cond.in` (any-of, wins when present) OR equals `cond.equals`. A
+ *   predicate with an empty `field` is a no-op (visible). A predicate that
+ *   names a field but declares neither `in` nor `equals` hides nothing
+ *   (visible) — nothing to gate on.
+ *
+ * `cond` may be the raw block off either the snake_case or camelCase slot; use
+ * `getVisibleWhen` to normalize first.
+ */
+export function evaluateVisibleWhen(
+    cond: VisibleWhen | null | undefined,
+    formValues: Record<string, any> | null | undefined,
+): boolean {
+    if (!cond || typeof cond.field !== 'string' || cond.field.trim() === '') return true
+    const raw = formValues ? formValues[cond.field.trim()] : undefined
+    const current = raw == null ? '' : String(raw)
+    const inList = cond.in
+    if (Array.isArray(inList) && inList.length > 0) {
+        return inList.some((v) => String(v) === current)
+    }
+    if (typeof cond.equals === 'string') {
+        return cond.equals === current
+    }
+    // Named a field but declared no comparison → nothing to gate on.
+    return true
+}
+
 /**
  * Reads a field's enriched options-resolution config, tolerating the camelCase
  * `optionsConfig` (authored SDK shape) and the snake_case `options_config` the

package/src/dynamic-form.tsx

@@ -2,6 +2,8 @@
 // pattern + ActionFieldDef renderer so callers can reuse the form layout
 // outside the full record-edit modal.
 import { useEffect, useMemo, useState } from 'react'
+import { groupFieldsBySection, type FormLayout } from './form-layout'
+import { FieldSection, WizardProgress } from './form-layout-ui'
 import {
     Input,
     Textarea,
@@ -22,6 +24,8 @@ import {
     evaluateBalance,
     applyOptionWhen,
     getDependsOn,
+    getVisibleWhen,
+    evaluateVisibleWhen,
 } from './dynamic-form-schema'
 import { useOptionsResolver, type ResolvedOption } from './use-options-resolver'
 import { DynamicLineItems } from './dynamic-line-items'
@@ -45,6 +49,14 @@ export interface DynamicFormProps {
     submitLabel?: string
     cancelLabel?: string
     disabled?: boolean
+    /**
+     * Declarative form layout served on the model metadata (kernel PR #230).
+     * When present the visible fields are grouped by their `section` respecting
+     * `sections` order: `mode:"sections"` stacks (optionally collapsible)
+     * sections; `mode:"steps"` renders a Anterior/Siguiente wizard. Absent → the
+     * legacy flat list (unchanged).
+     */
+    formLayout?: FormLayout
 }
 
 export function DynamicForm({
@@ -55,6 +67,7 @@ export function DynamicForm({
     submitLabel = 'Guardar',
     cancelLabel = 'Cancelar',
     disabled = false,
+    formLayout,
 }: DynamicFormProps) {
     const [values, setValues] = useState<Record<string, any>>({})
     const [errors, setErrors] = useState<Record<string, string>>({})
@@ -70,19 +83,47 @@ export function DynamicForm({
         [fields],
     )
 
-    const schema = useMemo(() => buildZodSchema(editableFields), [editableFields])
+    // Conditional visibility: a field carrying `visible_when` is rendered — and
+    // validated — only while the referenced sibling field's current value
+    // matches the predicate. Driving BOTH the schema and the render off the same
+    // filtered list means a hidden field never blocks submit (its required-gate
+    // is dropped with it), matching the primitive's contract. Fields with no
+    // `visible_when` are always kept (retrocompat).
+    const visibleFields = useMemo(
+        () => editableFields.filter((f) => evaluateVisibleWhen(getVisibleWhen(f), values)),
+        [editableFields, values],
+    )
+
+    const schema = useMemo(() => buildZodSchema(visibleFields), [visibleFields])
 
     // Line-items fields carrying a balance rule gate submit: an unbalanced entry
     // (Σdebit ≠ Σcredit, or all-zero when require_nonzero) can't be saved. This
     // is fully declarative — `evaluateBalance` returns undefined for fields with
     // no rule, so non-balanced forms are unaffected.
     const balanceBlocked = useMemo(() => {
-        for (const f of editableFields) {
+        for (const f of visibleFields) {
             const state = evaluateBalance(f, values[f.key])
             if (state && !state.balanced) return true
         }
         return false
-    }, [editableFields, values])
+    }, [visibleFields, values])
+
+    // Group visible fields by their form_layout section (empty sections drop out
+    // because visibleFields is already visibility-filtered). Without a layout
+    // this is a single default group → the render below collapses to the legacy
+    // flat grid, byte-for-byte.
+    const groups = useMemo(
+        () => groupFieldsBySection(visibleFields, formLayout),
+        [visibleFields, formLayout],
+    )
+    const isSteps = formLayout?.mode === 'steps' && groups.length > 1
+
+    // Wizard step cursor (steps mode only). Clamped whenever the group count
+    // shrinks (a visible_when flip can empty a trailing step's section).
+    const [stepIndex, setStepIndex] = useState(0)
+    useEffect(() => {
+        setStepIndex((i) => Math.min(i, Math.max(groups.length - 1, 0)))
+    }, [groups.length])
 
     useEffect(() => {
         const defaults: Record<string, any> = {}
@@ -118,25 +159,93 @@ export function DynamicForm({
         try { await onSubmit(result.data as Record<string, any>) } finally { setSubmitting(false) }
     }
 
+    // Renders one group's fields into the responsive 2-column grid: scalar
+    // header fields flow through it; line-items grids (and textareas) span full
+    // width so the row table / memo gets room. Shared by every layout mode.
+    const renderGrid = (groupFields: ActionFieldDef[]) => (
+        <div className="grid gap-4 sm:grid-cols-2">
+            {groupFields.map((field) => (
+                <FieldRow
+                    key={field.key}
+                    field={field}
+                    value={values[field.key]}
+                    onChange={(v: any) => update(field.key, v)}
+                    values={values}
+                    error={errors[field.key]}
+                    initialValues={initialValues}
+                />
+            ))}
+        </div>
+    )
+
+    // ── Steps (wizard) mode ────────────────────────────────────────────────
+    // One step per section; Anterior/Siguiente navigate, submit only on the
+    // last step. Advancing validates just the current step's fields so a later
+    // step can't be blocked by an earlier untouched one and vice-versa.
+    if (isSteps) {
+        const step = groups[stepIndex]
+        const isLast = stepIndex === groups.length - 1
+
+        const goNext = () => {
+            const stepSchema = buildZodSchema(step.fields)
+            const result = stepSchema.safeParse(values)
+            if (!result.success) {
+                const next: Record<string, string> = {}
+                for (const issue of result.error.issues) {
+                    const key = issue.path[0]
+                    if (typeof key === 'string' && !next[key]) next[key] = issue.message
+                }
+                setErrors(next)
+                return
+            }
+            setErrors({})
+            setStepIndex((i) => Math.min(i + 1, groups.length - 1))
+        }
+        const goBack = () => setStepIndex((i) => Math.max(i - 1, 0))
+
+        return (
+            <form onSubmit={handleSubmit} className="grid gap-4">
+                <WizardProgress groups={groups} stepIndex={stepIndex} />
+                {renderGrid(step.fields)}
+                <div className="flex justify-between gap-2 pt-2">
+                    {stepIndex > 0 ? (
+                        <Button type="button" variant="outline" onClick={goBack} disabled={submitting || disabled}>
+                            Anterior
+                        </Button>
+                    ) : onCancel ? (
+                        <Button type="button" variant="outline" onClick={onCancel} disabled={submitting || disabled}>
+                            {cancelLabel}
+                        </Button>
+                    ) : (
+                        <span />
+                    )}
+                    {isLast ? (
+                        <Button type="submit" disabled={submitting || disabled || balanceBlocked}>
+                            {submitLabel}
+                        </Button>
+                    ) : (
+                        <Button type="button" onClick={goNext} disabled={submitting || disabled}>
+                            Siguiente
+                        </Button>
+                    )}
+                </div>
+            </form>
+        )
+    }
+
+    // ── Sections / flat mode ───────────────────────────────────────────────
     // Layout: scalar header fields flow through a responsive 2-column grid;
     // line-items grids (and textareas) span the full width so the row table /
     // memo gets room. Mirrors the pro look of the federated journal modal but
-    // stays fully declarative — driven only by field shape.
+    // stays fully declarative — driven only by field shape. With no layout this
+    // is a single default group rendered without section chrome (unchanged).
     return (
         <form onSubmit={handleSubmit} className="grid gap-4">
-            <div className="grid gap-4 sm:grid-cols-2">
-                {editableFields.map((field) => (
-                    <FieldRow
-                        key={field.key}
-                        field={field}
-                        value={values[field.key]}
-                        onChange={(v: any) => update(field.key, v)}
-                        values={values}
-                        error={errors[field.key]}
-                        initialValues={initialValues}
-                    />
-                ))}
-            </div>
+            {groups.map((group) => (
+                <FieldSection key={group.key} group={group}>
+                    {renderGrid(group.fields)}
+                </FieldSection>
+            ))}
             <div className="flex justify-end gap-2 pt-2">
                 {onCancel && (
                     <Button type="button" variant="outline" onClick={onCancel} disabled={submitting || disabled}>

package/src/dynamic-relation.tsx

@@ -48,7 +48,7 @@ import { useTimeZone, useCurrency } from './org-runtime-context'
 import { makeDefaultGetDynamicColumns } from './dynamic-columns'
 import { isColumnVisibleInLineSubtable } from './column-visibility'
 import { useOptionsResolver } from './use-options-resolver'
-import type { ApiResponse, TableMetadata } from './types'
+import type { ApiResponse, ColumnDefinition, TableMetadata } from './types'
 import {
     buildCreatePayload,
     buildPivotAttachPayload,
@@ -120,6 +120,18 @@ interface CommonProps {
     filters?: Record<string, string>
     /** Hidden columns; el FK siempre se oculta automáticamente. */
     hiddenColumns?: string[]
+    /**
+     * Contexto de sub-tabla de líneas dentro del MODAL de vista de un registro
+     * padre. Cuando es true se aplican las reglas de {@link isColumnVisibleInLineSubtable}
+     * — se ocultan por defecto las columnas de auditoría/sistema (created_by,
+     * timestamps, organization_id) y las scopeadas a `visibility: "table"`, que
+     * son ruido redundante bajo el registro padre.
+     *
+     * Default false: en una página de detalle autónoma (`/m/<model>/<id>`) el
+     * panel de relación conserva el comportamiento previo (solo oculta FK, scope
+     * y columnas `hidden`), donde esas columnas SÍ son útiles.
+     */
+    lineSubtable?: boolean
     /** Permisos visibles. Default true. */
     canCreate?: boolean
     canDelete?: boolean
@@ -191,6 +203,7 @@ function OneToManyRelation({
     filters,
     endpoint,
     hiddenColumns = [],
+    lineSubtable = false,
     canCreate = true,
     canDelete = true,
     canEdit = true,
@@ -266,13 +279,17 @@ function OneToManyRelation({
         // Hide the FK and every scope column — they're fixed for this parent and
         // would just render the same value on every row.
         const hidden = new Set([foreignKey, ...Object.keys(filters || {}), ...hiddenColumns])
-        // isColumnVisibleInLineSubtable additionally drops `hidden`/table-scoped
-        // columns AND the audit/system noise (created_by, timestamps, org_id)
-        // that's redundant under a parent record — see column-visibility.ts.
-        return metadata.columns.filter(
-            c => !hidden.has(c.key) && isColumnVisibleInLineSubtable(c),
-        )
-    }, [metadata, foreignKey, filtersKey, hiddenColumns])
+        // In the view-modal line-subtable context, isColumnVisibleInLineSubtable
+        // additionally drops `hidden`/table-scoped columns AND the audit/system
+        // noise (created_by, timestamps, org_id) that's redundant under a parent
+        // record — see column-visibility.ts. Outside that context (standalone
+        // detail page) we keep the previous behaviour and only drop `hidden`
+        // columns, so those columns still show where they're useful.
+        const keep = lineSubtable
+            ? (c: ColumnDefinition) => !hidden.has(c.key) && isColumnVisibleInLineSubtable(c)
+            : (c: ColumnDefinition) => !hidden.has(c.key) && !c.hidden
+        return metadata.columns.filter(keep)
+    }, [metadata, foreignKey, filtersKey, hiddenColumns, lineSubtable])
 
     // Reuse the EXACT column factory the main `<DynamicTable>` uses so each cell
     // renders identically — money in the org currency right-aligned, FK chips

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/form-layout-ui.tsx

@@ -0,0 +1,117 @@
+// Presentational chrome for declarative form layouts (see `form-layout.ts`).
+// Kept apart from the grouping logic so the pure helper stays React-free and the
+// two renderers (`dynamic-form.tsx`, `dialogs/dynamic-record.tsx`) share one
+// look for sections and the wizard progress bar.
+import { useState } from 'react'
+import {
+    Collapsible,
+    CollapsibleContent,
+    CollapsibleTrigger,
+    Button,
+} from '@asteby/metacore-ui/primitives'
+import { ChevronDown } from 'lucide-react'
+import type { FieldGroup } from './form-layout'
+
+/**
+ * Section chrome for `mode: "sections"`. Wraps a group's (already gridded)
+ * fields in a titled block.
+ *  - The default/orphan group renders with NO chrome, so a layout-less form (one
+ *    default group) is visually identical to the legacy flat list.
+ *  - A section whose `collapsed` is defined (true/false) is rendered COLLAPSIBLE,
+ *    starting collapsed when `collapsed === true`. A section with no `collapsed`
+ *    flag renders as a plain, always-open titled block.
+ */
+export function FieldSection({
+    group,
+    children,
+}: {
+    group: FieldGroup<unknown>
+    children: React.ReactNode
+}) {
+    const collapsible = group.collapsed !== undefined
+    const [open, setOpen] = useState(!group.collapsed)
+
+    if (group.isDefault) return <>{children}</>
+
+    const header = (
+        <div className="min-w-0 text-left">
+            {group.title && (
+                <h3 className="text-sm font-semibold leading-none">{group.title}</h3>
+            )}
+            {group.description && (
+                <p className="pt-1 text-sm text-muted-foreground">{group.description}</p>
+            )}
+        </div>
+    )
+
+    if (!collapsible) {
+        return (
+            <section className="grid gap-3">
+                {(group.title || group.description) && header}
+                {children}
+            </section>
+        )
+    }
+
+    return (
+        <Collapsible open={open} onOpenChange={setOpen} className="grid gap-3">
+            <CollapsibleTrigger asChild>
+                <Button
+                    type="button"
+                    variant="ghost"
+                    className="h-auto w-full justify-between px-0 py-1 hover:bg-transparent"
+                >
+                    {header}
+                    <ChevronDown
+                        className={
+                            'h-4 w-4 shrink-0 transition-transform ' + (open ? 'rotate-180' : '')
+                        }
+                    />
+                </Button>
+            </CollapsibleTrigger>
+            <CollapsibleContent className="grid gap-3">{children}</CollapsibleContent>
+        </Collapsible>
+    )
+}
+
+/**
+ * Progress bar for `mode: "steps"`: one filled segment per completed/current
+ * step plus a "Paso i/n · <title>" caption. Mirrors the WizardActionModal look
+ * so a model wizard and an action wizard read the same.
+ */
+export function WizardProgress({
+    groups,
+    stepIndex,
+    stepLabel = 'Paso',
+}: {
+    groups: FieldGroup<unknown>[]
+    stepIndex: number
+    stepLabel?: string
+}) {
+    const current = groups[stepIndex]
+    return (
+        <div className="pt-2">
+            <div className="flex items-center gap-1.5" role="list" aria-label="progress">
+                {groups.map((g, i) => (
+                    <div
+                        key={g.key}
+                        role="listitem"
+                        aria-current={i === stepIndex ? 'step' : undefined}
+                        className="h-1.5 flex-1 rounded-full"
+                        style={{
+                            backgroundColor:
+                                i <= stepIndex ? 'hsl(var(--primary))' : 'hsl(var(--muted))',
+                        }}
+                    />
+                ))}
+            </div>
+            <p className="pt-2 text-sm text-muted-foreground">
+                {stepLabel} {stepIndex + 1}/{groups.length}
+                {current?.title ? ` · ${current.title}` : ''}
+            </p>
+            {current?.description && (
+                <p className="pt-1 text-sm text-muted-foreground">{current.description}</p>
+            )}
+        </div>
+    )
+}

package/src/form-layout.ts

@@ -0,0 +1,116 @@
+// Declarative form layout (kernel PR #230): a model's create/edit form can
+// declare `form_layout` to group its fields into named sections, rendered either
+// as stacked (optionally collapsible) SECTIONS or as a multi-step WIZARD.
+//
+// Wire shape served on the table/modal metadata:
+//   form_layout: {
+//     mode: "sections" | "steps",              // default "sections"
+//     sections: [{ key, title?, description?, collapsed? }]
+//   }
+// and, per field/column: `section: "<key>"` referencing a section key.
+//
+// This module owns the PURE grouping logic (no React), so the two renderers
+// (`dynamic-form.tsx`, `dialogs/dynamic-record.tsx`) share one tested
+// implementation and the modal-render machinery never has to be booted under
+// happy-dom just to assert the grouping (same approach as PR #673).
+
+/** One declared section of a model form. `title`/`description` arrive already
+ * localized from the kernel and are rendered verbatim. */
+export interface FormSection {
+    key: string
+    title?: string
+    description?: string
+    /** Sections mode only: render this section collapsed on first paint. */
+    collapsed?: boolean
+}
+
+/** Model-level layout directive. `mode` defaults to `"sections"`. */
+export interface FormLayout {
+    mode?: 'sections' | 'steps'
+    sections?: FormSection[]
+}
+
+/** A resolved group of fields ready to render: a section plus the (already
+ * visibility-filtered) fields that belong to it. */
+export interface FieldGroup<F> {
+    /** Section key, or `__default__` for the orphan group. */
+    key: string
+    title?: string
+    description?: string
+    collapsed?: boolean
+    /** True for the synthetic group holding section-less / unknown-section fields. */
+    isDefault: boolean
+    fields: F[]
+}
+
+/** The synthetic key of the orphan group (fields with no / unknown `section`). */
+export const DEFAULT_SECTION_KEY = '__default__'
+
+/** Reads a field's `section` reference, tolerating a camelCase alias. */
+export function getFieldSection(
+    field: { section?: string; Section?: string } | null | undefined,
+): string | undefined {
+    if (!field) return undefined
+    const s = field.section ?? (field as { Section?: string }).Section
+    return typeof s === 'string' && s !== '' ? s : undefined
+}
+
+/**
+ * Groups already-filtered (visible) fields by their `section`, honoring the
+ * order of `layout.sections`.
+ *
+ * Contract:
+ *  - No `layout` (or no `sections`) → a single default group carrying every
+ *    field in its original order. Callers render this exactly like the legacy
+ *    flat list, so the layout-less path is byte-for-byte the current behaviour.
+ *  - Fields whose `section` is empty or references an UNKNOWN section key are
+ *    collected into ONE default group placed FIRST (before any declared
+ *    section) — the consistent, documented choice: general/uncategorized fields
+ *    lead, declared sections follow in their authored order.
+ *  - A declared section with zero visible fields is OMITTED entirely, so a
+ *    section whose only members are hidden by `visible_when` never renders an
+ *    empty shell (and never yields an empty wizard step). Because the caller
+ *    passes the already visibility-filtered list, this falls out for free.
+ */
+export function groupFieldsBySection<F extends { section?: string }>(
+    fields: F[],
+    layout: FormLayout | undefined,
+): FieldGroup<F>[] {
+    if (!layout?.sections?.length) {
+        return [{ key: DEFAULT_SECTION_KEY, isDefault: true, fields }]
+    }
+
+    const known = new Set(layout.sections.map((s) => s.key))
+    const bySection = new Map<string, F[]>()
+    const orphans: F[] = []
+
+    for (const f of fields) {
+        const sec = getFieldSection(f)
+        if (sec && known.has(sec)) {
+            const arr = bySection.get(sec)
+            if (arr) arr.push(f)
+            else bySection.set(sec, [f])
+        } else {
+            orphans.push(f)
+        }
+    }
+
+    const groups: FieldGroup<F>[] = []
+    // Orphan/default group leads (fields with no / unknown section).
+    if (orphans.length) {
+        groups.push({ key: DEFAULT_SECTION_KEY, isDefault: true, fields: orphans })
+    }
+    for (const s of layout.sections) {
+        const secFields = bySection.get(s.key)
+        if (!secFields || secFields.length === 0) continue // hide empty section
+        groups.push({
+            key: s.key,
+            title: s.title,
+            description: s.description,
+            collapsed: s.collapsed,
+            isDefault: false,
+            fields: secFields,
+        })
+    }
+    return groups
+}

package/src/index.ts

@@ -107,6 +107,8 @@ export {
     type UseDynamicFiltersResult,
 } from './use-dynamic-filters'
 export * from './dynamic-form'
+export * from './form-layout'
+export * from './form-layout-ui'
 export { FieldGrid, FieldCell, FieldLabel } from './field-grid'
 export {
     ActionModalDispatcher,
@@ -307,6 +309,8 @@ export {
     resolveDependsValue,
     getOptionsConfig,
     resolveOptionsSource,
+    getVisibleWhen,
+    evaluateVisibleWhen,
 } from './dynamic-form-schema'
 export {
     ActivityValueRenderer,