@asteby/metacore-runtime-react 47.1.0 → 49.0.0

package/src/document-form-dialog.tsx

@@ -23,6 +23,7 @@ import {
 import { Loader2 } from 'lucide-react'
 import { toast } from 'sonner'
 import { useApi } from './api-context'
+import { useOrgTaxRate } from './org-runtime-context'
 import { DynamicIcon } from './dynamic-icon'
 import { FieldCell, FieldGrid, FieldLabel } from './field-grid'
 import { FormErrorBanner } from './business/feedback'
@@ -41,12 +42,13 @@ import { extractFieldErrors, localizeFieldErrorMap } from './server-error'
 import { validateValues, bagHasErrors } from './validator'
 import { clearFieldErrorTree } from './field-validation-ui'
 import { emitRecordMutation } from './record-mutation-events'
-import { isLineItemsField, resolveWidget } from './dynamic-form-schema'
+import { isLineItemsField, resolveWidget, scopeValueFromFilterToken } from './dynamic-form-schema'
+import { createCatalogProductSearch, withDefaultTaxRate } from './business/catalog-product-search'
+import { DocumentEditor } from './business/document-editor'
+import { editorLinesConfig, isEditorLayout } from './business/document-editor-model'
 import type {
     ActionFieldDef,
-    DocumentFormLines,
     DocumentFormsManifest,
-    DocumentFormType,
     TableMetadata,
 } from './types'
 
@@ -62,10 +64,24 @@ export interface DocumentFormDialogProps {
     initialType?: string
     /** Se llama con el registro creado. */
     onSaved?: (record?: unknown) => void
-    /** Buscador de productos para el editor de renglones (mismo contrato que ProductPicker). */
+    /**
+     * Buscador de productos para el editor de renglones (mismo contrato que
+     * ProductPicker). Sin él se busca en el catálogo (`productModel`) vía /data.
+     */
     searchProducts?: DocumentLinesGridProps['search']
+    /** Modelo de catálogo del buscador por defecto. Default `products.Product`. */
+    productModel?: string
+    /** Tasa de impuesto (0.16) si el producto no trae la suya. Default: la de la org (OrgRuntimeProvider). */
+    defaultTaxRate?: number
     /** Moneda ISO para el editor de renglones (default: la de la org). */
     currency?: string
+    /**
+     * Registro desde el que se abre (acción de fila «Crear NC», «Registrar
+     * cobro»…): siembra los campos con `default_from_record`.
+     */
+    record?: Record<string, any>
+    /** Documento origen a precargar en el DocumentEditor (`sources[].key` + id). */
+    initialSource?: { key: string; id: string }
 }
 
 /** Manifest efectivo: la prop gana sobre el metadata; sin tipos devuelve undefined. */
@@ -77,10 +93,25 @@ export function resolveDocumentForms(
     return m && Array.isArray(m.types) && m.types.length > 0 ? m : undefined
 }
 
-function linesConfig(type: DocumentFormType, forms: DocumentFormsManifest): (DocumentFormLines & { field: string }) | undefined {
-    if (!type.lines) return undefined
-    const cfg: DocumentFormLines = type.lines === true ? {} : type.lines
-    return { ...cfg, field: cfg.field ?? forms.lines_field ?? 'lines' }
+/**
+ * Acota el alta guiada a la vista filtrada. Un nav que filtra por la columna
+ * discriminadora (`type_field`) lista UN tipo de documento: «Crear» debe abrir
+ * ese tipo directo y, si el manifest no trae formulario para él, no ofrecerse
+ * (retest r3: «Documentos fiscales → Facturas → Crear» abría el REP, el único
+ * tipo declarado). Sin manifest, sin `type_field` o sin filtro sobre él, todo
+ * queda igual.
+ */
+export function scopeDocumentFormsToFilter(
+    forms: DocumentFormsManifest | undefined,
+    filter?: Record<string, unknown> | null,
+): { forms: DocumentFormsManifest | undefined; hideCreate: boolean } {
+    const field = forms?.type_field
+    if (!forms || !field || !filter || !(field in filter)) return { forms, hideCreate: false }
+    const want = scopeValueFromFilterToken(filter[field]).trim().toLowerCase()
+    if (want === '') return { forms, hideCreate: false }
+    const types = forms.types.filter((x) => String(x.value ?? x.key).trim().toLowerCase() === want)
+    if (types.length === 0) return { forms: undefined, hideCreate: true }
+    return { forms: types.length === forms.types.length ? forms : { ...forms, types }, hideCreate: false }
 }
 
 type Step = 'type' | 'fields' | 'lines'
@@ -94,10 +125,15 @@ export function DocumentFormDialog({
     initialType,
     onSaved,
     searchProducts,
+    productModel,
+    defaultTaxRate,
     currency,
+    record,
+    initialSource,
 }: DocumentFormDialogProps) {
     const { t, i18n } = useTranslation()
     const api = useApi()
+    const orgTaxRate = useOrgTaxRate()
     const types = forms.types
     const single = types.length === 1 ? types[0] : undefined
 
@@ -111,7 +147,19 @@ export function DocumentFormDialog({
     const [saving, setSaving] = useState(false)
 
     const type = useMemo(() => types.find((x) => x.key === typeKey) ?? null, [types, typeKey])
-    const lineCfg = type ? linesConfig(type, forms) : undefined
+    // Sin buscador inyectado, el paso de renglones solo ofrecía «Renglón libre»
+    // y la línea entraba sin precio (DynamicCRUDPage no pasa searchProducts).
+    // Default: el catálogo de productos de la org. El buscador del host también
+    // recibe el IVA de la org para los productos que no traen su tasa.
+    const taxRate = defaultTaxRate ?? orgTaxRate
+    const lineSearch = useMemo(
+        () =>
+            searchProducts
+                ? withDefaultTaxRate(searchProducts, taxRate)
+                : createCatalogProductSearch(api, { model: productModel, defaultTaxRate: taxRate }),
+        [searchProducts, api, productModel, taxRate],
+    )
+    const lineCfg = type ? editorLinesConfig(type, forms) : undefined
 
     // Reset every time the dialog (re)opens.
     useEffect(() => {
@@ -128,10 +176,10 @@ export function DocumentFormDialog({
     // Seed field defaults for the chosen type.
     useEffect(() => {
         if (!type) return
-        setFormData({ ...buildFieldDefaults(type.fields, undefined), ...(type.defaults ?? {}) })
+        setFormData({ ...buildFieldDefaults(type.fields, record), ...(type.defaults ?? {}) })
         setFieldErrors({})
         setFormError(undefined)
-    }, [type])
+    }, [type, record])
 
     const updateField = (key: string, value: any) => {
         setFormData((prev) => ({ ...prev, [key]: value }))
@@ -232,6 +280,41 @@ export function DocumentFormDialog({
               ? t('documentForm.step_data', { defaultValue: 'Datos' })
               : tl(lineCfg?.title ?? 'Renglones')
 
+    // layout "editor": una sola pantalla por secciones (DocumentEditor). Sin él
+    // sigue el wizard de siempre (retrocompatible).
+    if (open && type && step !== 'type' && (isEditorLayout(type) || !!initialSource)) {
+        return (
+            <Dialog open={open} onOpenChange={onOpenChange}>
+                <DialogContent
+                    className="flex max-h-[92dvh] flex-col overflow-hidden"
+                    style={{ maxHeight: '92dvh', maxWidth: '960px', width: '95vw' }}
+                    data-slot="document-editor-dialog"
+                >
+                    <DialogHeader className="shrink-0">
+                        <DialogTitle>{tl(type.label)}</DialogTitle>
+                        {type.description && <DialogDescription>{tl(type.description)}</DialogDescription>}
+                    </DialogHeader>
+                    <DocumentEditor
+                        key={type.key}
+                        model={model}
+                        endpoint={endpoint}
+                        forms={forms}
+                        type={type}
+                        record={record}
+                        initialSource={initialSource}
+                        searchProducts={lineSearch}
+                        currency={currency}
+                        onCancel={() => (canGoBackToTypes ? setStep('type') : onOpenChange(false))}
+                        onSaved={(rec) => {
+                            onSaved?.(rec)
+                            onOpenChange(false)
+                        }}
+                    />
+                </DialogContent>
+            </Dialog>
+        )
+    }
+
     return (
         <Dialog open={open} onOpenChange={onOpenChange}>
             <DialogContent
@@ -311,8 +394,9 @@ export function DocumentFormDialog({
                             }}
                             columns={(lineCfg.columns as LineItemsColumn[] | undefined) ?? ['discount', 'tax']}
                             priceSource={lineCfg.price_source ?? 'sale'}
+                            discountMode={lineCfg.discount_mode}
                             serverErrors={serverLineErrors}
-                            search={searchProducts}
+                            search={lineSearch}
                             currency={currency}
                         />
                     )}

package/src/dynamic-columns-helpers.ts

@@ -78,3 +78,25 @@ export function translateMetadataLabel(
     const translated = translate(value, { defaultValue: fallback })
     return translated && translated !== value ? translated : fallback
 }
+
+// A catalog key as addons write them: lowercase dotted segments
+// ("fiscal_mexico.ext.customer.rfc_receptor"). Human labels have spaces,
+// capitals or accents and never match.
+const CATALOG_KEY_RE = /^[a-z0-9_]+(\.[a-z0-9_]+)+$/
+
+/**
+ * Form-field label as the user should read it. The host usually serves labels
+ * already localized; when it could not (an extension field whose addon catalog
+ * the server did not resolve), the label arrives as the raw catalog key and the
+ * form printed `FISCAL_MEXICO.EXT.CUSTOMER.RFC_RECEPTOR`. Such a key is resolved
+ * with the client catalog and, failing that, humanized. Any other label is
+ * returned untouched.
+ */
+export function localizeFieldLabel(
+    label: string | undefined,
+    translate?: MetadataTranslator,
+): string {
+    if (!label) return ''
+    if (!CATALOG_KEY_RE.test(label)) return label
+    return translateMetadataLabel(label, translate)
+}

package/src/dynamic-columns.tsx

@@ -17,7 +17,7 @@ import { ColumnDef } from '@tanstack/react-table'
 import { format, type Locale } from 'date-fns'
 import { isCalendarDayValue, parseCalendarDate } from './calendar-date'
 import { es, enUS } from 'date-fns/locale'
-import { Calendar, Check, Copy, Mail, Minus, MoreHorizontal } from 'lucide-react'
+import { Calendar, Check, Copy, Mail, Minus } from 'lucide-react'
 import {
     Avatar,
     AvatarFallback,
@@ -25,10 +25,6 @@ import {
     Badge,
     Button,
     Checkbox,
-    DropdownMenu,
-    DropdownMenuContent,
-    DropdownMenuItem,
-    DropdownMenuTrigger,
     InitialsAvatar,
 } from '@asteby/metacore-ui'
 import {
@@ -57,7 +53,7 @@ import { DynamicIcon, isLucideIconName } from './dynamic-icon'
 import { CollectionCell } from './collection-cell'
 import { isNilUuid, normalizeNilUuid } from './nil-uuid'
 import { useOptionsResolver } from './use-options-resolver'
-import { RequiresAddonLock, resolveRequiresAddon, useRequiresAddonLabel } from './requires-addon'
+import { RowActionsMenu } from './row-actions-menu'
 import type { TableMetadata, ColumnDefinition } from './types'
 import { isColumnVisibleInTable } from './column-visibility'
 import type {
@@ -208,42 +204,25 @@ const CodeCell: React.FC<{ text: string; maxLength?: number }> = ({ text, maxLen
     )
 }
 
-/**
- * One entry of the row "…" menu. An action gated by a missing optional addon
- * (`requiresAddon`) stays listed with a lock + tooltip; the click still goes to
- * `onAction`, whose shared handler (useDynamicRowActions) opens the
- * requires-addon dialog instead of executing.
- */
-export function RowActionMenuItem({
-    action,
-    label,
-    onSelect,
-}: {
-    action: any
-    label: React.ReactNode
-    onSelect: (e: React.MouseEvent) => void
-}) {
-    const requirement = resolveRequiresAddon(action)
-    const requiresAddonLabel = useRequiresAddonLabel()
-    return (
-        <DropdownMenuItem
-            onClick={onSelect}
-            title={requirement ? requiresAddonLabel(requirement) : undefined}
-            data-requires-addon={requirement?.key}
-        >
-            <DynamicIcon name={action.icon || 'Zap'} className="mr-2 h-4 w-4" />
-            {label}
-            {requirement && <RequiresAddonLock requirement={requirement} />}
-        </DropdownMenuItem>
-    )
-}
+// RowActionMenuItem vive en row-actions-menu.tsx (junto al menú que lo usa);
+// se re-exporta aquí por compatibilidad (dynamic-kanban, hosts).
+export { RowActionMenuItem } from './row-actions-menu'
 
 /**
  * Lifecycle column used by `requiresState`: prefer `status` (workshop, vehicles,
  * …) and fall back to `state` (purchases, inventory transfers, …). Empty string
  * is treated as missing so a blank `status` does not hide a populated `state`.
  */
-const rowLifecycleState = (row: any): unknown => {
+const rowLifecycleState = (row: any, stageField?: string): unknown => {
+    // A model with a stage machine gates its actions on the stage column, the
+    // same field the kernel's checkRequiresState reads (dynamic/action.go).
+    // Without this, WorkOrder actions declared with stage keys
+    // (requiresState: ['reception', …]) were compared to `status` ('open') and
+    // hidden in every row, so an OT could never be advanced from the UI.
+    if (stageField) {
+        const stage = row?.[stageField]
+        if (stage !== undefined && stage !== null && stage !== '') return stage
+    }
     const status = row?.status
     if (status !== undefined && status !== null && status !== '') return status
     const state = row?.state
@@ -264,10 +243,10 @@ const rowLifecycleState = (row: any): unknown => {
  *   - action without requiresState (or empty array)  → always shown.
  *   - row with neither `status` nor `state`          → all actions shown.
  */
-export const isActionAllowedForRowState = (action: any, row: any): boolean => {
+export const isActionAllowedForRowState = (action: any, row: any, stageField?: string): boolean => {
     const requires: unknown = action?.requiresState ?? action?.requires_state
     if (!Array.isArray(requires) || requires.length === 0) return true
-    const status = rowLifecycleState(row)
+    const status = rowLifecycleState(row, stageField)
     if (status === undefined) return true
     return requires.map(String).includes(String(status))
 }
@@ -341,8 +320,16 @@ export const isActionConditionMet = (action: any, row: any): boolean => {
  * (`requiresState`) AND the declarative `condition` must pass. Shared by the
  * table's action column and the kanban card menu so they hide/show identically.
  */
-export const isRowActionVisible = (action: any, row: any): boolean =>
-    isActionAllowedForRowState(action, row) && isActionConditionMet(action, row)
+export const isRowActionVisible = (action: any, row: any, stageField?: string): boolean =>
+    isActionAllowedForRowState(action, row, stageField) && isActionConditionMet(action, row)
+
+/**
+ * The column a model's `requiresState` gates read: the served `stage_field`
+ * (or, for hosts that predate it, the `group_by` of a model with stages).
+ * Undefined → the historical `status` / `state` lookup.
+ */
+export const lifecycleStageField = (metadata: any): string | undefined =>
+    metadata?.stage_field ?? metadata?.stageField ?? (metadata?.stages?.length ? metadata?.group_by : undefined)
 
 const lowerFirst = (value?: string) => {
     if (!value) return value
@@ -1554,28 +1541,14 @@ export function makeDefaultGetDynamicColumns(
                 maxSize: 80,
                 meta: {},
                 cell: ({ row }) => (
-                    <div className="flex items-center justify-end">
-                        <DropdownMenu>
-                            <DropdownMenuTrigger asChild>
-                                <Button variant="ghost" className="h-8 w-8 p-0">
-                                    <span className="sr-only">Abrir menú</span>
-                                    <MoreHorizontal className="h-4 w-4" />
-                                </Button>
-                            </DropdownMenuTrigger>
-                            <DropdownMenuContent align="end">
-                                {resolvedActions
-                                    .filter((action) => isRowActionVisible(action, row.original))
-                                    .map((action) => (
-                                        <RowActionMenuItem
-                                            key={action.key}
-                                            action={action}
-                                            label={translateMetadataLabel(action.label, t)}
-                                            onSelect={() => onAction && onAction(action.key, row.original)}
-                                        />
-                                    ))}
-                            </DropdownMenuContent>
-                        </DropdownMenu>
-                    </div>
+                    // Primaria destacada, principales y un «Más…» con las
+                    // secundarias (compartir/imprimir/correo/chat + las que
+                    // aporten addons instalados). Ver row-actions-menu.tsx.
+                    <RowActionsMenu
+                        actions={resolvedActions.filter((action) => isRowActionVisible(action, row.original, lifecycleStageField(metadata)))}
+                        row={row.original}
+                        onAction={onAction}
+                    />
                 ),
             })
         }

package/src/dynamic-crud-page.tsx

@@ -33,7 +33,7 @@ import { useApi } from './api-context'
 import { useMetadataCache } from './metadata-cache'
 import { DynamicTable } from './dynamic-table'
 import { DynamicRecordDialog } from './dialogs/dynamic-record'
-import { DocumentFormDialog, resolveDocumentForms } from './document-form-dialog'
+import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from './document-form-dialog'
 import { ExportDialog } from './dialogs/export'
 import { ImportDialog } from './dialogs/import'
 import { getModelExtension } from './model-extension-registry'
@@ -96,6 +96,18 @@ export interface DynamicCRUDPageProps {
      * with neither, the generic record dialog is used as before.
      */
     documentForms?: DocumentFormsManifest
+    /**
+     * Filtro fijo de la vista (el `filter` del nav). Si va sobre el `type_field`
+     * del alta guiada, «Crear» abre ese tipo directo o se oculta cuando no hay
+     * formulario para él.
+     */
+    filter?: Record<string, string>
+    /**
+     * Abre el alta guiada al montar («crear desde»): tipo de documento y origen
+     * a precargar (`sources[].key` + id), p. ej. leídos de la URL
+     * `?create=<tipo>&from=<fuente>&from_id=<id>`. Solo con document_forms.
+     */
+    initialCreate?: { type?: string; source?: { key: string; id: string } }
 }
 
 /**
@@ -119,6 +131,8 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
         classes,
         onChange,
         documentForms,
+        filter,
+        initialCreate,
     } = props
 
     const strings = { ...defaultStrings, ...(i18n ?? {}) }
@@ -130,7 +144,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
 
     const [metadata, setMetadata] = useState<TableMetadata | null>(cachedMeta ?? null)
     const [refreshKey, setRefreshKey] = useState(0)
-    const [openCreate, setOpenCreate] = useState(false)
+    const [openCreate, setOpenCreate] = useState(!!initialCreate)
     const [openExport, setOpenExport] = useState(false)
     const [openImport, setOpenImport] = useState(false)
 
@@ -189,11 +203,22 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
     // (useCan defaults to always-true), in which case create/export/import
     // require `lowercase(model).create|export|import`.
     const can = useCan()
-    const showCreate = primary.showGenericCreate && can(modelCapability(model, 'create'))
+    const scoped = scopeDocumentFormsToFilter(resolveDocumentForms(metadata, documentForms), filter)
+    const guidedForms = scoped.forms
+    const showCreate = primary.showGenericCreate && !scoped.hideCreate && can(modelCapability(model, 'create'))
     const showImport = enableCRUD && !effectiveHideImport && can(modelCapability(model, 'import'))
     const showExport = !effectiveHideExport && can(modelCapability(model, 'export'))
     const showRefresh = !effectiveHideRefresh
-    const guidedForms = resolveDocumentForms(metadata, documentForms)
+
+    // El mismo filtro acota la tabla (forma `eq:<valor>` que espera DynamicTable).
+    const filterKey = filter ? JSON.stringify(filter) : ''
+    const tableFilters = useMemo(() => {
+        if (!filter || Object.keys(filter).length === 0) return undefined
+        return Object.fromEntries(
+            Object.entries(filter).map(([k, v]) => [k, String(v).includes(':') ? String(v) : `eq:${v}`]),
+        )
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [filterKey])
 
     const handleRefresh = useCallback(() => {
         setRefreshKey((k) => k + 1)
@@ -278,6 +303,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
                         model={model}
                         endpoint={dataEndpoint}
                         refreshTrigger={refreshKey}
+                        defaultFilters={tableFilters}
                     />
                 </div>
             </div>
@@ -289,13 +315,15 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
                     model={model}
                     endpoint={dataEndpoint}
                     forms={guidedForms}
+                    initialType={initialCreate?.type}
+                    initialSource={initialCreate?.source}
                     onSaved={handleRefresh}
                 />
             )}
 
             {showCreate && !guidedForms && (
                 <DynamicRecordDialog
-                    open={openCreate}
+                    open={openCreate && !initialCreate?.source}
                     onOpenChange={setOpenCreate}
                     mode='create'
                     model={model}

package/src/dynamic-form-schema.ts

@@ -107,12 +107,25 @@ export function computeLineItemTotals(
     field: ActionFieldDef,
     rows: any[] | undefined,
 ): Record<string, number> {
-    const cols = getItemFields(field).filter((c) => c.total)
+    const itemFields = getItemFields(field)
+    const cols = itemFields.filter((c) => c.total)
+    // A `total` UNIT PRICE column on a grid with a quantity and no line amount
+    // column sums the line amounts (qty × price − discount): adding unit prices
+    // is meaningless once a quantity exists (2 × 750 footed 750, not 1500).
+    const qtyKey = firstKey(itemFields, LINE_QTY_KEYS)
+    const lineValued = !!qtyKey && !firstKey(itemFields, LINE_AMOUNT_KEYS)
+    const discountKey = firstKey(itemFields, LINE_DISCOUNT_KEYS)
     const totals: Record<string, number> = {}
     for (const c of cols) totals[c.key] = 0
     if (Array.isArray(rows)) {
         for (const row of rows) {
-            for (const c of cols) totals[c.key] += toNumber(row?.[c.key])
+            for (const c of cols) {
+                const v = toNumber(row?.[c.key])
+                totals[c.key] +=
+                    lineValued && LINE_PRICE_KEYS.has(c.key)
+                        ? toNumber(row?.[qtyKey!]) * v - (discountKey ? toNumber(row?.[discountKey]) : 0)
+                        : v
+            }
         }
     }
     for (const k of Object.keys(totals)) totals[k] = Math.round(totals[k] * 100) / 100