@asteby/metacore-runtime-react 49.0.0 → 49.2.0

package/src/document-form-dialog.tsx

@@ -23,7 +23,7 @@ import {
 import { Loader2 } from 'lucide-react'
 import { toast } from 'sonner'
 import { useApi } from './api-context'
-import { useOrgTaxRate } from './org-runtime-context'
+import { useOrgTaxRate, useTimeZone } from './org-runtime-context'
 import { DynamicIcon } from './dynamic-icon'
 import { FieldCell, FieldGrid, FieldLabel } from './field-grid'
 import { FormErrorBanner } from './business/feedback'
@@ -45,9 +45,10 @@ import { emitRecordMutation } from './record-mutation-events'
 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 { editorLinesConfig, isEditorLayout, isFullscreenEditor } from './business/document-editor-model'
 import type {
     ActionFieldDef,
+    DocumentFormType,
     DocumentFormsManifest,
     TableMetadata,
 } from './types'
@@ -82,6 +83,39 @@ export interface DocumentFormDialogProps {
     record?: Record<string, any>
     /** Documento origen a precargar en el DocumentEditor (`sources[].key` + id). */
     initialSource?: { key: string; id: string }
+    /**
+     * Tipo con `create_model`: el alta vive en otro modelo. El host navega a la
+     * página de ese modelo con su alta abierta; el diálogo se cierra sin pintar
+     * formulario. Sin este callback un tipo delegado no se ofrece.
+     */
+    onDelegateCreate?: (target: DelegatedCreate) => void
+}
+
+/** Alta delegada a otro modelo (`document_forms.types[].create_model`). */
+export interface DelegatedCreate {
+    /** Clave del modelo destino tal como la declara el manifest (`customers.Invoice`). */
+    model: string
+    /** Tipo que la declaró. */
+    type: DocumentFormType
+}
+
+/**
+ * Si «Crear» de estos formularios es un alta delegada: un único tipo (p. ej.
+ * ya acotado por el filtro de la vista) con `create_model`. Con varios tipos el
+ * selector la ofrece como una tarjeta más.
+ */
+export function delegatedCreate(forms: DocumentFormsManifest | undefined): DelegatedCreate | undefined {
+    const only = forms?.types.length === 1 ? forms.types[0] : undefined
+    const model = only?.create_model?.trim()
+    return only && model ? { model, type: only } : undefined
+}
+
+/** Quita los tipos delegados cuando el host no sabe navegar a otro modelo. */
+export function withoutDelegatedTypes(forms: DocumentFormsManifest | undefined): DocumentFormsManifest | undefined {
+    if (!forms) return forms
+    const types = forms.types.filter((x) => !x.create_model?.trim())
+    if (types.length === forms.types.length) return forms
+    return types.length > 0 ? { ...forms, types } : undefined
 }
 
 /** Manifest efectivo: la prop gana sobre el metadata; sin tipos devuelve undefined. */
@@ -130,11 +164,17 @@ export function DocumentFormDialog({
     currency,
     record,
     initialSource,
+    onDelegateCreate,
 }: DocumentFormDialogProps) {
     const { t, i18n } = useTranslation()
     const api = useApi()
     const orgTaxRate = useOrgTaxRate()
-    const types = forms.types
+    const orgTimeZone = useTimeZone()
+    // Sin onDelegateCreate el host no sabe abrir otro modelo: sus tipos no se ofrecen.
+    const types = useMemo(
+        () => (onDelegateCreate ? forms.types : forms.types.filter((x) => !x.create_model?.trim())),
+        [forms.types, onDelegateCreate],
+    )
     const single = types.length === 1 ? types[0] : undefined
 
     const [typeKey, setTypeKey] = useState<string | null>(initialType ?? single?.key ?? null)
@@ -147,6 +187,16 @@ export function DocumentFormDialog({
     const [saving, setSaving] = useState(false)
 
     const type = useMemo(() => types.find((x) => x.key === typeKey) ?? null, [types, typeKey])
+    const delegatedModel = type?.create_model?.trim() || undefined
+
+    // Tipo con alta en otro modelo: no hay formulario aquí; el host navega.
+    useEffect(() => {
+        if (!open || !type || !delegatedModel) return
+        onDelegateCreate?.({ model: delegatedModel, type })
+        onOpenChange(false)
+        // onDelegateCreate/onOpenChange: callbacks del host, no disparan de nuevo.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [open, type, delegatedModel])
     // 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
@@ -176,10 +226,13 @@ export function DocumentFormDialog({
     // Seed field defaults for the chosen type.
     useEffect(() => {
         if (!type) return
-        setFormData({ ...buildFieldDefaults(type.fields, record), ...(type.defaults ?? {}) })
+        setFormData({
+            ...buildFieldDefaults(type.fields, record, undefined, { timeZone: orgTimeZone }),
+            ...(type.defaults ?? {}),
+        })
         setFieldErrors({})
         setFormError(undefined)
-    }, [type, record])
+    }, [type, record, orgTimeZone])
 
     const updateField = (key: string, value: any) => {
         setFormData((prev) => ({ ...prev, [key]: value }))
@@ -280,15 +333,25 @@ export function DocumentFormDialog({
               ? t('documentForm.step_data', { defaultValue: 'Datos' })
               : tl(lineCfg?.title ?? 'Renglones')
 
+    if (open && type && delegatedModel) return null
+
     // layout "editor": una sola pantalla por secciones (DocumentEditor). Sin él
-    // sigue el wizard de siempre (retrocompatible).
+    // sigue el wizard de siempre (retrocompatible). Un documento con renglones
+    // (factura, cotización, pedido, OC) ocupa toda la pantalla; NC y cobro
+    // siguen en el diálogo grande.
     if (open && type && step !== 'type' && (isEditorLayout(type) || !!initialSource)) {
+        const fullscreen = isFullscreenEditor(type, forms)
         return (
             <Dialog open={open} onOpenChange={onOpenChange}>
                 <DialogContent
-                    className="flex max-h-[92dvh] flex-col overflow-hidden"
-                    style={{ maxHeight: '92dvh', maxWidth: '960px', width: '95vw' }}
+                    className={fullscreen ? 'flex flex-col overflow-hidden sm:max-w-none' : 'flex max-h-[92dvh] flex-col overflow-hidden'}
+                    style={
+                        fullscreen
+                            ? { width: 'calc(100vw - 2rem)', maxWidth: '1440px', height: 'calc(100dvh - 2rem)', maxHeight: 'calc(100dvh - 2rem)' }
+                            : { maxHeight: '92dvh', maxWidth: '960px', width: '95vw' }
+                    }
                     data-slot="document-editor-dialog"
+                    data-fullscreen={fullscreen ? 'true' : undefined}
                 >
                     <DialogHeader className="shrink-0">
                         <DialogTitle>{tl(type.label)}</DialogTitle>
@@ -304,6 +367,7 @@ export function DocumentFormDialog({
                         initialSource={initialSource}
                         searchProducts={lineSearch}
                         currency={currency}
+                        fullscreen={fullscreen}
                         onCancel={() => (canGoBackToTypes ? setStep('type') : onOpenChange(false))}
                         onSaved={(rec) => {
                             onSaved?.(rec)

package/src/dynamic-crud-page.tsx

@@ -33,7 +33,13 @@ import { useApi } from './api-context'
 import { useMetadataCache } from './metadata-cache'
 import { DynamicTable } from './dynamic-table'
 import { DynamicRecordDialog } from './dialogs/dynamic-record'
-import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from './document-form-dialog'
+import {
+    DocumentFormDialog,
+    resolveDocumentForms,
+    scopeDocumentFormsToFilter,
+    withoutDelegatedTypes,
+    type DelegatedCreate,
+} from './document-form-dialog'
 import { ExportDialog } from './dialogs/export'
 import { ImportDialog } from './dialogs/import'
 import { getModelExtension } from './model-extension-registry'
@@ -108,6 +114,12 @@ export interface DynamicCRUDPageProps {
      * `?create=<tipo>&from=<fuente>&from_id=<id>`. Solo con document_forms.
      */
     initialCreate?: { type?: string; source?: { key: string; id: string } }
+    /**
+     * Alta delegada (`document_forms.types[].create_model`): el host abre la
+     * página del modelo destino con su alta abierta. Sin él, esos tipos no se
+     * ofrecen (y si la vista queda acotada a uno, no hay «Crear»).
+     */
+    onDelegateCreate?: (target: DelegatedCreate) => void
 }
 
 /**
@@ -133,6 +145,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
         documentForms,
         filter,
         initialCreate,
+        onDelegateCreate,
     } = props
 
     const strings = { ...defaultStrings, ...(i18n ?? {}) }
@@ -203,7 +216,11 @@ 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 scoped = scopeDocumentFormsToFilter(resolveDocumentForms(metadata, documentForms), filter)
+    const declaredForms = resolveDocumentForms(metadata, documentForms)
+    const scoped = scopeDocumentFormsToFilter(
+        onDelegateCreate ? declaredForms : withoutDelegatedTypes(declaredForms),
+        filter,
+    )
     const guidedForms = scoped.forms
     const showCreate = primary.showGenericCreate && !scoped.hideCreate && can(modelCapability(model, 'create'))
     const showImport = enableCRUD && !effectiveHideImport && can(modelCapability(model, 'import'))
@@ -318,6 +335,7 @@ export function DynamicCRUDPage(props: DynamicCRUDPageProps) {
                     initialType={initialCreate?.type}
                     initialSource={initialCreate?.source}
                     onSaved={handleRefresh}
+                    onDelegateCreate={onDelegateCreate}
                 />
             )}
 

package/src/index.ts

@@ -179,8 +179,11 @@ export { FieldGrid, FieldCell, FieldLabel } from './field-grid'
 export {
     ActionModalDispatcher,
     FEDERATED_ACTION_MODAL_TIMEOUT_MS,
+    resolveFieldDefault,
     type ActionModalProps,
+    type FieldDefaultContext,
 } from './action-modal-dispatcher'
+export { todayInZone, isTodayToken } from './calendar-date'
 export { setFederatedActionLoader, type FederatedActionLoader } from './federated-action-loader'
 export {
     ModelActionToolbar,
@@ -198,8 +201,10 @@ export {
 } from './list-primary-action'
 export {
     emitRecordMutation,
+    emitRecordMutationSettled,
     subscribeRecordMutations,
     RECORD_MUTATION_EVENT,
+    RECORD_MUTATION_SETTLE_DELAYS,
     type RecordMutationKind,
     type RecordMutationDetail,
 } from './record-mutation-events'
@@ -207,6 +212,9 @@ export {
     DocumentFormDialog,
     resolveDocumentForms,
     scopeDocumentFormsToFilter,
+    delegatedCreate,
+    withoutDelegatedTypes,
+    type DelegatedCreate,
     type DocumentFormDialogProps,
 } from './document-form-dialog'
 export {

package/src/record-mutation-events.ts

@@ -31,6 +31,29 @@ export function emitRecordMutation(model: string | undefined | null, kind: Recor
     }
 }
 
+/**
+ * Delays (ms) at which a mutation is announced again. The backend's event
+ * subscribers write AFTER the action answered (stamping → the invoice's state,
+ * a payment → its auto-stamped REP), so a list or tab that reloaded at once kept
+ * showing the previous state until a manual reload (retest Pitsline r5).
+ */
+export const RECORD_MUTATION_SETTLE_DELAYS: readonly number[] = [1500, 5000]
+
+/**
+ * Announce a mutation now and again after `delays`, so what the server derives
+ * asynchronously from it reaches mounted lists too. Returns a cancel function.
+ */
+export function emitRecordMutationSettled(
+    model: string | undefined | null,
+    kind: RecordMutationKind,
+    delays: readonly number[] = RECORD_MUTATION_SETTLE_DELAYS,
+): () => void {
+    emitRecordMutation(model, kind)
+    if (!model || typeof window === 'undefined') return () => {}
+    const timers = delays.map((ms) => window.setTimeout(() => emitRecordMutation(model, kind), ms))
+    return () => timers.forEach((t) => window.clearTimeout(t))
+}
+
 /**
  * Listen for mutations of `model` (case-insensitive). Returns an unsubscribe.
  */

package/src/types.ts

@@ -107,6 +107,13 @@ export interface DocumentFormType {
      * reparte el pago en PaymentAllocation dentro de una transacción.
      */
     submit_action?: string
+    /**
+     * El alta de este tipo vive en OTRO modelo (`customers.Invoice`): «Crear»
+     * no pinta formulario, el host abre la página de ese modelo con su alta
+     * abierta (`onDelegateCreate`). P. ej. Documentos fiscales → Facturas: la
+     * factura nace en customers y se timbra después. Sin campos ni renglones.
+     */
+    create_model?: string
 }
 
 /** Contraparte: qué campo del encabezado la elige y qué muestra su tarjeta. */