@asteby/metacore-runtime-react 28.7.0 → 29.0.0

package/src/dynamic-relation.tsx

@@ -3,7 +3,7 @@
 //   - "one_to_many": lista inline editable que cuelga del registro padre.
 //   - "many_to_many": multi-select sobre la tabla destino con sync a la pivot.
 // La RFC completa vive en `packages/runtime-react/docs/relations.md`.
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
     type ColumnDef,
@@ -31,6 +31,7 @@ import {
     DialogContent,
     DialogHeader,
     DialogTitle,
+    Input,
     MultiSelect,
     Table,
     TableBody,
@@ -39,7 +40,7 @@ import {
     TableHeader,
     TableRow,
 } from '@asteby/metacore-ui/primitives'
-import { Plus, Trash2, Pencil } from 'lucide-react'
+import { Plus, Trash2, Pencil, Search } from 'lucide-react'
 import { useApi } from './api-context'
 import { useMetadataCache } from './metadata-cache'
 import { DynamicForm } from './dynamic-form'
@@ -48,6 +49,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 { dedupeById, useInfiniteScrollSentinel } from './use-infinite-scroll'
 import type { ApiResponse, ColumnDefinition, TableMetadata } from './types'
 import {
     buildCreatePayload,
@@ -90,6 +92,10 @@ export interface DynamicRelationStrings {
     selectPlaceholder: string
     selectSearchPlaceholder: string
     selectEmpty: string
+    /** Placeholder del buscador de la sub-tabla 1:N. */
+    searchPlaceholder: string
+    /** Pie de la sub-tabla: "{{loaded}} de {{total}}". */
+    countLabel: string
 }
 
 const DEFAULT_STRINGS: DynamicRelationStrings = {
@@ -105,8 +111,15 @@ const DEFAULT_STRINGS: DynamicRelationStrings = {
     selectPlaceholder: 'Seleccionar…',
     selectSearchPlaceholder: 'Buscar…',
     selectEmpty: 'Sin resultados.',
+    searchPlaceholder: 'Buscar…',
+    countLabel: '{{loaded}} de {{total}}',
 }
 
+// Tamaño de página de la sub-tabla 1:N. Antes la lista pedía el hijo COMPLETO
+// (sin page/per_page), así que abrir un almacén traía todas sus existencias y
+// traspasos. Se pagina de a 25 y el resto entra por scroll infinito.
+const REL_PAGE_SIZE = 25
+
 interface CommonProps {
     /** id del registro padre. */
     parentId: string | number
@@ -233,6 +246,15 @@ function OneToManyRelation({
     const [metadata, setMetadata] = useState<TableMetadata | null>(cachedMeta || null)
     const [rows, setRows] = useState<any[]>([])
     const [loading, setLoading] = useState(true)
+    // Paginación server-side + scroll infinito, igual que <DynamicTable>.
+    const [total, setTotal] = useState(0)
+    const [page, setPage] = useState(1)
+    const [loadingMore, setLoadingMore] = useState(false)
+    // El backend devolvió una página corta: no hay más filas aunque meta.total
+    // diga otra cosa (drift count/list dispararía el sentinel para siempre).
+    const [exhausted, setExhausted] = useState(false)
+    const [search, setSearch] = useState('')
+    const [debouncedSearch, setDebouncedSearch] = useState('')
     const [formOpen, setFormOpen] = useState(false)
     const [editingRow, setEditingRow] = useState<any | null>(null)
     const [rowToDelete, setRowToDelete] = useState<any | null>(null)
@@ -244,12 +266,31 @@ function OneToManyRelation({
     // still reacting to real scope changes.
     const filtersKey = useMemo(() => (filters ? JSON.stringify(filters) : ''), [filters])
 
-    const fetchAll = useCallback(async () => {
-        setLoading(true)
+    // La metadata se lee por ref dentro del fetch: si entrara como dependencia,
+    // resolverla dispararía un segundo fetch de datos por cada montaje.
+    const metadataRef = useRef<TableMetadata | null>(metadata)
+    metadataRef.current = metadata
+
+    // Debounce del buscador: cada tecla no puede pegarle al servidor.
+    useEffect(() => {
+        const id = setTimeout(() => setDebouncedSearch(search.trim()), 300)
+        return () => clearTimeout(id)
+    }, [search])
+
+    // fetchPage REEMPLAZA (página 1) o ANEXA (scroll infinito). Antes esta lista
+    // pedía el modelo hijo entero sin page/per_page.
+    const fetchPage = useCallback(async (nextPage: number, append: boolean) => {
+        if (append) setLoadingMore(true)
+        else setLoading(true)
         try {
-            const params = buildRelationFilterParams(foreignKey, parentId, filters)
+            const params: Record<string, any> = {
+                ...buildRelationFilterParams(foreignKey, parentId, filters),
+                page: nextPage,
+                per_page: REL_PAGE_SIZE,
+            }
+            if (debouncedSearch) params.search = debouncedSearch
             const [metaRes, dataRes] = await Promise.all([
-                metadata ? Promise.resolve(null) : api.get(`/metadata/table/${model}`),
+                metadataRef.current ? Promise.resolve(null) : api.get(`/metadata/table/${model}`),
                 api.get(dataEndpoint, { params }),
             ])
             if (metaRes && (metaRes as any).data?.success) {
@@ -258,16 +299,41 @@ function OneToManyRelation({
                 cacheMetadata(model, fresh)
             }
             const list = (dataRes as { data: ApiResponse<any[]> }).data
-            if (list.success) setRows(list.data || [])
+            if (list.success) {
+                const fetched = list.data || []
+                setRows((prev) => (append ? dedupeById(prev, fetched) : fetched))
+                setPage(nextPage)
+                if (list.meta?.total !== undefined) setTotal(list.meta.total)
+                else if (!append) setTotal(fetched.length)
+                setExhausted(fetched.length < REL_PAGE_SIZE)
+            }
         } catch (err) {
             console.error('DynamicRelation fetch error', err)
         } finally {
-            setLoading(false)
+            if (append) setLoadingMore(false)
+            else setLoading(false)
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [api, dataEndpoint, foreignKey, parentId, filtersKey, metadata, model, cacheMetadata])
+    }, [api, dataEndpoint, foreignKey, parentId, filtersKey, model, cacheMetadata, debouncedSearch])
+
+    // Recarga desde la primera página. Es lo que corren create/edit/delete.
+    const fetchAll = useCallback(async () => {
+        await fetchPage(1, false)
+    }, [fetchPage])
 
-    useEffect(() => { fetchAll() }, [fetchAll])
+    // Un cambio de padre/scope/búsqueda vuelve a la página 1.
+    useEffect(() => { fetchPage(1, false) }, [fetchPage])
+
+    const canLoadMore = !loading && !loadingMore && !exhausted && rows.length < total
+    const { rootRef, sentinelRef } = useInfiniteScrollSentinel<HTMLDivElement, HTMLDivElement>({
+        onLoadMore: () => { if (canLoadMore) fetchPage(page + 1, true) },
+        disabled: !canLoadMore,
+    })
+
+    // El buscador solo aparece cuando hay algo que buscar: una sub-tabla de 3
+    // líneas no necesita chrome extra. Se queda visible mientras haya término
+    // activo para no dejar al usuario sin forma de limpiarlo.
+    const showSearch = debouncedSearch !== '' || search !== '' || total > REL_PAGE_SIZE
 
     const formFields = useMemo(
         () => deriveRelationFormFields(metadata, foreignKey),
@@ -410,19 +476,32 @@ function OneToManyRelation({
 
     return (
         <div className={className} data-relation-kind={kind} data-relation-model={model}>
-            {(labels.title || canCreate) && (
-                <div className="flex items-center justify-between pb-3">
+            {(labels.title || canCreate || showSearch) && (
+                <div className="flex items-center justify-between gap-2 pb-3">
                     {labels.title ? <h3 className="text-sm font-medium">{labels.title}</h3> : <span />}
-                    {canCreate && (
-                        <Button
-                            size="sm"
-                            variant="outline"
-                            onClick={() => { setEditingRow(null); setFormOpen(true) }}
-                        >
-                            <Plus className="h-4 w-4 mr-1" />
-                            {labels.addLabel}
-                        </Button>
-                    )}
+                    <div className="flex items-center gap-2">
+                        {showSearch && (
+                            <div className="relative">
+                                <Search className="absolute start-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+                                <Input
+                                    value={search}
+                                    onChange={(e: React.ChangeEvent<HTMLInputElement>) => setSearch(e.target.value)}
+                                    placeholder={labels.searchPlaceholder}
+                                    className="h-8 w-40 ps-7 sm:w-56"
+                                />
+                            </div>
+                        )}
+                        {canCreate && (
+                            <Button
+                                size="sm"
+                                variant="outline"
+                                onClick={() => { setEditingRow(null); setFormOpen(true) }}
+                            >
+                                <Plus className="h-4 w-4 mr-1" />
+                                {labels.addLabel}
+                            </Button>
+                        )}
+                    </div>
                 </div>
             )}
 
@@ -440,7 +519,10 @@ function OneToManyRelation({
                 // Real metadata-driven table — same metacore-ui primitives and
                 // cell renderers as `<DynamicTable>` so headers, money/currency,
                 // FK thumbnails, dates and badges all match the main table.
-                <div className="overflow-x-auto border rounded-md bg-card">
+                // `max-h` + scroll propio: la sub-tabla no puede estirar el modal
+                // del padre a lo alto de cientos de filas. El sentinel del fondo
+                // pide la página siguiente al entrar en vista.
+                <div ref={rootRef} className="overflow-auto max-h-[60vh] border rounded-md bg-card">
                     <Table noWrapper className="w-full">
                         <TableHeader>
                             {table.getHeaderGroups().map((headerGroup: HeaderGroup<any>) => (
@@ -477,6 +559,22 @@ function OneToManyRelation({
                             ))}
                         </TableBody>
                     </Table>
+                    {loadingMore && (
+                        <div className="p-2">
+                            <Skeleton className="h-8 w-full" />
+                        </div>
+                    )}
+                    <div ref={sentinelRef} aria-hidden className="h-px w-full" />
+                </div>
+            )}
+
+            {/* Cuánto de la relación se ve. Sin esto una sub-tabla paginada
+                miente: parece completa cuando solo trae la primera página. */}
+            {!loading && rows.length > 0 && total > rows.length && (
+                <div className="pt-2 text-end text-xs text-muted-foreground">
+                    {labels.countLabel
+                        .replace('{{loaded}}', String(rows.length))
+                        .replace('{{total}}', String(total))}
                 </div>
             )}
 

package/src/dynamic-relations.tsx

@@ -49,6 +49,19 @@ export interface DynamicRelationsProps {
      * autónoma conserva todas las columnas.
      */
     lineSubtable?: boolean
+    /**
+     * Solo renderiza las relaciones de COMPOSICIÓN — las que el kernel marca
+     * con `embed: true` (las líneas de un documento). Es lo que usan los MODALES
+     * de registro: antes embebían TODAS las relaciones one_to_many del modelo,
+     * así que abrir "Editar Almacén" arrastraba miles de existencias y traspasos
+     * al formulario. Las relaciones no embebidas siguen accesibles desde su
+     * propia página / la vista de detalle, que renderiza el listado completo.
+     *
+     * Default false: una página de detalle autónoma sigue mostrando todas.
+     * Una relación sin `embed` (kernel viejo) NO se embebe — el gate falla del
+     * lado seguro.
+     */
+    embedOnly?: boolean
     /** Bubble up when any panel's data changes (create/delete/attach/detach). */
     onChange?: (relation: RelationMeta) => void
 }
@@ -90,6 +103,17 @@ export function buildRelationFilters(
     return out
 }
 
+/**
+ * ¿La relación es de COMPOSICIÓN (embebible en un modal)? Solo `embed: true`
+ * califica: la ausencia del flag — un kernel viejo que todavía no lo sirve —
+ * significa NO embeber, que es el lado seguro (el costo de un falso negativo
+ * es un panel de menos en el modal; el de un falso positivo, miles de filas
+ * dentro de un formulario).
+ */
+export function isEmbedded(rel: Pick<RelationMeta, 'embed'>): boolean {
+    return rel.embed === true
+}
+
 /** Stable React key for a relation panel. */
 function relationKey(rel: RelationMeta, idx: number): string {
     return rel.name || `${rel.through}-${rel.foreign_key}-${idx}`
@@ -106,6 +130,7 @@ export function DynamicRelations({
     canEdit = true,
     strings,
     lineSubtable = false,
+    embedOnly = false,
     onChange,
 }: DynamicRelationsProps) {
     const parentId = useMemo(
@@ -113,7 +138,14 @@ export function DynamicRelations({
         [record, parentIdKey],
     )
 
-    if (parentId === undefined || !relations || relations.length === 0) {
+    // Gate de composición: en un modal solo entran las relaciones marcadas
+    // `embed` por el kernel. Fuera del modal la lista pasa entera.
+    const visible = useMemo(
+        () => (embedOnly ? (relations || []).filter(isEmbedded) : relations || []),
+        [relations, embedOnly],
+    )
+
+    if (parentId === undefined || visible.length === 0) {
         return null
     }
 
@@ -122,7 +154,7 @@ export function DynamicRelations({
         // 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) => {
+            {visible.map((rel, idx) => {
                 const filters = buildRelationFilters(rel, parentId)
                 const panelStrings: Partial<DynamicRelationStrings> = {
                     ...(strings || {}),

package/src/entity-select.tsx

@@ -0,0 +1,316 @@
+// EntitySelect — the shared, permission-aware single-select for a related model.
+//
+// A searchable async combobox over a kernel model's records, plus the two
+// affordances every "pick a related record" control should have, exactly like
+// the dynamic create modal's relation fields (Categoría/Marca) do:
+//
+//   - nothing selected → a "+" that opens the model's CREATE dialog, and
+//     auto-selects the record it creates;
+//   - a record selected → a pencil that opens that record's EDIT dialog.
+//
+// Both affordances are gated by the kernel permissions (useCan): the "+" only
+// shows when the user can create the model, the pencil only when they can edit
+// it. Everything is DYNAMIC — the create/edit form comes from the model's
+// `/metadata/modal/:model` schema via <CreateRecordDialog>, so no per-model form
+// code is needed. This lives in the SDK so POS, purchases and any future addon
+// share ONE implementation instead of each re-porting a bespoke picker.
+import { useCallback, useEffect, useState } from 'react'
+import { Search, X, Plus, Pencil, type LucideIcon } from 'lucide-react'
+import {
+    Button,
+    Command,
+    CommandEmpty,
+    CommandGroup,
+    CommandInput,
+    CommandItem,
+    CommandList,
+    Popover,
+    PopoverContent,
+    PopoverTrigger,
+} from '@asteby/metacore-ui'
+import { CreateRecordDialog } from './dialogs/create-record-dialog'
+import { useCan } from './permissions-context'
+import { useApi } from './api-context'
+
+/** One searchable option: `value` is the id, `label` the display text. */
+export interface EntitySelectOption {
+    value: string
+    label: string
+    description?: string
+}
+
+export interface EntitySelectProps {
+    /** Kernel model key (e.g. "Supplier", "Warehouse", "Category"). */
+    model: string
+    /** Currently selected id (or null). */
+    value: string | null
+    /** Label of the selected record (rendered without a re-fetch). */
+    label: string | null
+    /** Called with (id, label) on select/create/clear. */
+    onSelect: (id: string | null, label: string | null) => void
+    /** Async search over the model. Callers pass their `/api/options/<model>` fetcher. */
+    fetcher: (q: string, signal: AbortSignal) => Promise<EntitySelectOption[]>
+
+    icon?: LucideIcon
+    placeholder?: string
+    searchPlaceholder?: string
+    emptyText?: string
+    /** Preload first results on open and drop the 2-char gate. */
+    preload?: boolean
+
+    /**
+     * Permission overrides. By default create/edit are gated by the kernel
+     * permissions `<model>.create` / `<model>.update` (useCan). Pass explicit
+     * booleans to force them (e.g. a read-only surface).
+     */
+    canCreate?: boolean
+    canEdit?: boolean
+
+    /**
+     * CRUD endpoint base for the create/edit dialog. Defaults to the standard
+     * org-scoped `/data/<model>/me`, with edit at `/data/<model>/me/<id>`.
+     */
+    endpoint?: string
+    /** Record field used as the label after create/edit (default "name"). */
+    labelField?: string
+    /** Disable the whole control. */
+    disabled?: boolean
+}
+
+/** Lowercase model → permission capability namespace (Supplier → supplier). */
+function capabilityNamespace(model: string): string {
+    return model.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
+}
+
+export function EntitySelect({
+    model,
+    value,
+    label,
+    onSelect,
+    fetcher,
+    icon: Icon,
+    placeholder = 'Seleccionar…',
+    searchPlaceholder = 'Buscar…',
+    emptyText = 'Sin resultados',
+    preload = false,
+    canCreate,
+    canEdit,
+    endpoint,
+    labelField = 'name',
+    disabled = false,
+}: EntitySelectProps) {
+    const can = useCan()
+    const api = useApi()
+
+    const ns = capabilityNamespace(model)
+    const mayCreate = canCreate ?? can(`${ns}.create`)
+    const mayEdit = canEdit ?? can(`${ns}.update`)
+    const base = endpoint ?? `/data/${model}/me`
+
+    const [open, setOpen] = useState(false)
+    const [dialogOpen, setDialogOpen] = useState(false)
+    const [dialogRecordId, setDialogRecordId] = useState<string | undefined>(undefined)
+    const [searchTerm, setSearchTerm] = useState('')
+    const [results, setResults] = useState<EntitySelectOption[]>([])
+    const [isLoading, setIsLoading] = useState(false)
+
+    const minChars = preload ? 0 : 2
+
+    const run = useCallback(
+        async (q: string, signal: AbortSignal) => {
+            if (q.length < minChars) {
+                setResults([])
+                return
+            }
+            setIsLoading(true)
+            try {
+                const rows = await fetcher(q, signal)
+                if (!signal.aborted) setResults(rows)
+            } catch {
+                if (!signal.aborted) setResults([])
+            } finally {
+                if (!signal.aborted) setIsLoading(false)
+            }
+        },
+        [fetcher, minChars],
+    )
+
+    useEffect(() => {
+        if (!open) return
+        const controller = new AbortController()
+        const timeout = setTimeout(() => run(searchTerm, controller.signal), 250)
+        return () => {
+            clearTimeout(timeout)
+            controller.abort()
+        }
+    }, [searchTerm, run, open])
+
+    const pick = (row: EntitySelectOption) => {
+        onSelect(row.value, row.label)
+        setOpen(false)
+        setSearchTerm('')
+    }
+
+    const clear = (e: React.MouseEvent) => {
+        e.stopPropagation()
+        onSelect(null, null)
+    }
+
+    const openCreate = (e: React.MouseEvent) => {
+        e.stopPropagation()
+        setDialogRecordId(undefined)
+        setDialogOpen(true)
+    }
+    const openEdit = (e: React.MouseEvent) => {
+        e.stopPropagation()
+        if (!value) return
+        setDialogRecordId(value)
+        setDialogOpen(true)
+    }
+
+    // Read the {id,label} off a saved record and select it. The transport
+    // matches the standard org-scoped CRUD the dynamic modal uses, so create/edit
+    // stay consistent with the rest of the app.
+    const selectSaved = (rec: Record<string, unknown> | undefined | null) => {
+        if (!rec) return
+        const id = rec.id != null ? String(rec.id) : value ?? ''
+        const lbl =
+            (rec[labelField] != null && String(rec[labelField])) ||
+            (rec.name != null && String(rec.name)) ||
+            label ||
+            id
+        onSelect(id, lbl)
+    }
+
+    return (
+        <div className="flex items-center gap-1.5">
+            <Popover open={open} onOpenChange={disabled ? undefined : setOpen}>
+                <PopoverTrigger asChild>
+                    <Button
+                        variant="outline"
+                        disabled={disabled}
+                        className="w-full flex-1 justify-start gap-2 font-normal"
+                    >
+                        {Icon && <Icon className="text-muted-foreground size-4 shrink-0" />}
+                        <span className="flex-1 truncate text-left">{label ?? placeholder}</span>
+                        {value && (
+                            <span
+                                role="button"
+                                tabIndex={0}
+                                onClick={clear}
+                                onKeyDown={(e) => {
+                                    if (e.key === 'Enter' || e.key === ' ')
+                                        clear(e as unknown as React.MouseEvent)
+                                }}
+                                className="hover:bg-accent ml-auto shrink-0 rounded-sm p-0.5"
+                            >
+                                <X className="size-3.5" />
+                            </span>
+                        )}
+                    </Button>
+                </PopoverTrigger>
+                <PopoverContent
+                    className="p-0"
+                    align="start"
+                    style={{ width: 'var(--radix-popover-trigger-width)' }}
+                >
+                    <Command shouldFilter={false}>
+                        <CommandInput
+                            placeholder={searchPlaceholder}
+                            value={searchTerm}
+                            onValueChange={setSearchTerm}
+                        />
+                        <CommandList>
+                            {isLoading && (
+                                <div className="text-muted-foreground py-4 text-center text-sm">
+                                    Buscando…
+                                </div>
+                            )}
+                            {!isLoading &&
+                                searchTerm.length >= minChars &&
+                                results.length === 0 && <CommandEmpty>{emptyText}</CommandEmpty>}
+                            {!isLoading && results.length > 0 && (
+                                <CommandGroup className="max-h-64 overflow-auto">
+                                    {results.map((row) => (
+                                        <CommandItem
+                                            key={row.value}
+                                            value={row.value}
+                                            onSelect={() => pick(row)}
+                                            className="flex flex-col items-start gap-0.5"
+                                        >
+                                            <span className="text-sm font-medium">{row.label}</span>
+                                            {row.description && (
+                                                <span className="text-muted-foreground text-xs">
+                                                    {row.description}
+                                                </span>
+                                            )}
+                                        </CommandItem>
+                                    ))}
+                                </CommandGroup>
+                            )}
+                            {!isLoading && !preload && searchTerm.length < minChars && (
+                                <div className="text-muted-foreground flex flex-col items-center gap-1 py-6">
+                                    <Search className="size-5" />
+                                    <span className="text-xs">Escribe al menos 2 caracteres</span>
+                                </div>
+                            )}
+                        </CommandList>
+                    </Command>
+                </PopoverContent>
+            </Popover>
+
+            {/* Selected → edit (pencil); empty → create (+). Each gated by perms. */}
+            {value
+                ? mayEdit && (
+                      <Button
+                          type="button"
+                          variant="outline"
+                          size="icon"
+                          disabled={disabled}
+                          onClick={openEdit}
+                          aria-label="Editar"
+                          title="Editar"
+                          className="shrink-0"
+                      >
+                          <Pencil className="size-4" />
+                      </Button>
+                  )
+                : mayCreate && (
+                      <Button
+                          type="button"
+                          variant="outline"
+                          size="icon"
+                          disabled={disabled}
+                          onClick={openCreate}
+                          aria-label="Crear"
+                          title="Crear"
+                          className="shrink-0"
+                      >
+                          <Plus className="size-4" />
+                      </Button>
+                  )}
+
+            {dialogOpen && (
+                <CreateRecordDialog
+                    modelKey={model}
+                    open={dialogOpen}
+                    onOpenChange={setDialogOpen}
+                    recordId={dialogRecordId}
+                    endpoint={base}
+                    onCreate={async (data) => {
+                        const res = await api.post(base, data)
+                        const rec = (res.data?.data ?? res.data) as Record<string, unknown>
+                        selectSaved(rec)
+                        return rec.id != null ? { id: String(rec.id) } : undefined
+                    }}
+                    onUpdate={async (id, data) => {
+                        const res = await api.put(`${base}/${id}`, data)
+                        const rec = (res.data?.data ?? res.data) as Record<string, unknown>
+                        selectSaved({ id, ...rec })
+                        return { id: String(id) }
+                    }}
+                />
+            )}
+        </div>
+    )
+}

package/src/index.ts

@@ -175,6 +175,8 @@ export * from './navigation-builder'
 export * from './i18n-provider'
 export * from './api-context'
 export * from './use-addon-settings'
+export * from './use-print-document'
+export * from './print-document-button'
 export * from './metadata-cache'
 export {
     ADDON_MANIFEST_CHANGED_TYPE,
@@ -242,6 +244,8 @@ export { DynamicRecordDialog, ViewValue } from './dialogs/dynamic-record'
 export { normalizeRefFieldsForSubmit } from './dialogs/normalize-submit'
 export type { DynamicRecordDialogProps, FieldDef, FieldOption, GetImageUrl } from './dialogs/dynamic-record'
 export { CreateRecordDialog } from './dialogs/create-record-dialog'
+export { EntitySelect } from './entity-select'
+export type { EntitySelectProps, EntitySelectOption } from './entity-select'
 export { ViewRecordDialog } from './dialogs/view-record-dialog'
 export type {
     ModelKey,
@@ -273,6 +277,7 @@ export {
     DynamicRelations,
     resolveParentId,
     buildRelationFilters,
+    isEmbedded,
     type DynamicRelationsProps,
 } from './dynamic-relations'
 export {