@groupteknology/vuno 0.1.0

package/dist/runtime/app/components/Table/Table.vue.d.ts

@@ -0,0 +1,70 @@
+import type { VunoFieldSlots } from '#vuno/types/field';
+import type { VunoTableDefinition, VunoTableFailure, VunoTableQuery, VunoTableRow } from '#vuno/types/table';
+declare const __VLS_export: <TRow extends VunoTableRow>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<({
+        data: TRow[];
+        definition: VunoTableDefinition<TRow>;
+        /**
+         * Fallo de la consulta. Sin esto, un error se pintaría como «no hay
+         * resultados» y la tabla afirmaría que no hay nada cuando en realidad
+         * no se pudo saber.
+         */
+        failure?: VunoTableFailure;
+        loading?: boolean;
+        /** Total de filas en servidor, no las de la página actual. */
+        total?: number;
+        ui?: VunoFieldSlots;
+    } & {
+        /**
+             * Estado de consulta. El consumidor lo observa y devuelve `data` y `total`.
+             *
+             * Es obligatorio a propósito: la tabla no trae datos por sí misma, así que
+             * un estado interno avanzaría de página sin que nadie pidiera la siguiente
+             * —el pie diría «11-20» mientras se siguen viendo las filas 1-10—. Dónde
+             * vive ese estado lo decide `useVunoTableQuery`: un `ref` normal o la
+             * query string.
+             */
+        query: VunoTableQuery;
+        /** Claves de las filas seleccionadas, no las filas: con paginación en servidor las de otras páginas no están cargadas. */
+        selection?: (number | string)[];
+    }) & {
+        onRowClick?: ((row: TRow) => any) | undefined;
+        "onUpdate:query"?: ((value: VunoTableQuery) => any) | undefined;
+        "onUpdate:selection"?: ((value: (string | number)[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        clearFilters: () => void;
+        clearSearch: () => void;
+        clearSelection: () => void;
+        goToPage: (page: number) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        [key: `cell-${string}`]: (props: {
+            row: TRow;
+            value: unknown;
+        }) => unknown;
+        empty?: () => unknown;
+        'empty-actions'?: () => unknown;
+        selection?: (props: {
+            count: number;
+            keys: (number | string)[];
+            clear: () => void;
+        }) => unknown;
+        toolbar?: (props: {
+            query: VunoTableQuery;
+        }) => unknown;
+    };
+    emit: ((evt: "rowClick", row: TRow) => void) & (((event: "update:query", value: VunoTableQuery) => void) & ((event: "update:selection", value: (string | number)[]) => void));
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/app/components/Table/TableCell.d.vue.ts

@@ -0,0 +1,8 @@
+import type { VunoTableColumn, VunoTableRow } from '#vuno/types/table';
+type __VLS_Props = {
+    column: VunoTableColumn;
+    row: VunoTableRow;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/TableCell.vue

@@ -0,0 +1,84 @@
+<script setup>
+import { computed } from "vue";
+import { useLocale } from "@nuxt/ui/composables";
+import { formatCurrency, formatDate, formatNumber } from "#vuno/utils/format";
+import { getPath } from "#vuno/utils/path";
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true }
+});
+const locale = useLocale();
+const value = computed(() => getPath(props.row, props.column.key));
+const text = computed(() => {
+  const raw = value.value;
+  if (raw === null || raw === void 0) return "";
+  return String(raw);
+});
+const badge = computed(() => {
+  if (props.column.type !== "badge") return null;
+  const entry = props.column.map?.[text.value];
+  return {
+    color: entry?.color ?? props.column.color ?? "neutral",
+    label: entry?.label ?? text.value
+  };
+});
+const alt = computed(() => {
+  if (props.column.type !== "image") return "";
+  if (props.column.altKey) return String(getPath(props.row, props.column.altKey) ?? "");
+  return props.column.alt ?? "";
+});
+</script>
+
+<template>
+    <span
+        v-if="props.column.type === 'number'"
+        class="tabular-nums"
+    >
+        {{ formatNumber(value, locale.code.value, props.column.decimals) }}
+    </span>
+
+    <span
+        v-else-if="props.column.type === 'currency'"
+        class="tabular-nums"
+    >
+        {{ formatCurrency(value, locale.code.value, props.column.currency, props.column.decimals) }}
+    </span>
+
+    <span
+        v-else-if="props.column.type === 'date'"
+        class="tabular-nums"
+    >
+        {{ formatDate(value, locale.code.value, { dateStyle: props.column.dateStyle ?? "medium", ...props.column.timeStyle ? { timeStyle: props.column.timeStyle } : {} }) }}
+    </span>
+
+    <UBadge
+        v-else-if="props.column.type === 'badge' && badge"
+        :color="badge.color"
+        :label="badge.label"
+        variant="subtle"
+    />
+
+    <UIcon
+        v-else-if="props.column.type === 'boolean' && !props.column.trueLabel && !props.column.falseLabel"
+        :class="value ? 'text-success' : 'text-muted'"
+        :name="value ? 'lucide:check' : 'lucide:minus'"
+    />
+
+    <span v-else-if="props.column.type === 'boolean'">
+        {{ value ? props.column.trueLabel ?? "" : props.column.falseLabel ?? "" }}
+    </span>
+
+    <UAvatar
+        v-else-if="props.column.type === 'image'"
+        :alt="alt"
+        :size="props.column.size ?? 'md'"
+        :src="text"
+    />
+
+    <span
+        v-else
+        :class="props.column.type === 'text' && props.column.truncate ? 'block max-w-[32ch] truncate' : void 0"
+    >
+        {{ text }}
+    </span>
+</template>

package/dist/runtime/app/components/Table/TableCell.vue.d.ts

@@ -0,0 +1,8 @@
+import type { VunoTableColumn, VunoTableRow } from '#vuno/types/table';
+type __VLS_Props = {
+    column: VunoTableColumn;
+    row: VunoTableRow;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/composables/useVunoCrud.d.ts

@@ -0,0 +1,23 @@
+import type { VunoCrud, VunoCrudOptions } from '#vuno/types/crud';
+import type { VunoTableRow } from '#vuno/types/table';
+/**
+ * El ciclo completo de una pantalla de mantenimiento: listar, dar de alta o
+ * editar en un modal, borrar con confirmación, refrescar la caché y avisar.
+ *
+ * Existe porque ese ciclo es idéntico en todas las entidades y, escrito a mano,
+ * son unas cien líneas por pantalla en las que es fácil olvidar justo lo que no
+ * se ve: invalidar la caché, avisar del fallo o distinguir un listado vacío de
+ * uno que no se pudo cargar.
+ *
+ * ```ts
+ * const crud = useVunoCrud({
+ *   key: 'brands',
+ *   list: (query) => $fetch('/api/brands', { query }),
+ *   create: (form) => $fetch('/api/brands', { body: form, method: 'POST' }),
+ *   update: (id, form) => $fetch(`/api/brands/${id}`, { body: form, method: 'PATCH' }),
+ *   remove: (row) => $fetch(`/api/brands/${row.id}`, { method: 'DELETE' }),
+ *   emptyForm: () => ({ name: '', slug: '' }),
+ * })
+ * ```
+ */
+export declare function useVunoCrud<TRow extends VunoTableRow, TForm extends Record<string, unknown>>(options: VunoCrudOptions<TRow, TForm>): VunoCrud<TRow, TForm>;

package/dist/runtime/app/composables/useVunoCrud.js

@@ -0,0 +1,117 @@
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/vue-query";
+import { useToast } from "@nuxt/ui/composables";
+import { computed, ref, shallowRef } from "vue";
+import { getPath } from "#vuno/utils/path";
+import { useVunoMessages } from "./useVunoTheme.js";
+import { useVunoTableQuery } from "./useVunoTableQuery.js";
+export function useVunoCrud(options) {
+  const toast = useToast();
+  const queryClient = useQueryClient();
+  const messages = useVunoMessages();
+  const query = options.query ?? useVunoTableQuery();
+  const baseKey = computed(() => Array.isArray(options.key) ? options.key : [options.key]);
+  const rowKey = options.rowKey ?? "id";
+  const text = computed(() => ({
+    created: options.messages?.created ?? messages.value.created,
+    createFailed: options.messages?.createFailed ?? messages.value.saveFailed,
+    deleted: options.messages?.deleted ?? messages.value.deleted,
+    deleteFailed: options.messages?.deleteFailed ?? messages.value.deleteFailed,
+    updated: options.messages?.updated ?? messages.value.updated,
+    updateFailed: options.messages?.updateFailed ?? messages.value.saveFailed
+  }));
+  const { data, isError, isPending, refetch } = useQuery({
+    // Sin esto, cambiar de filtro o de página deja `data` en undefined
+    // mientras llega la respuesta y la tabla parpadea enseñando su estado
+    // vacío. Con los datos anteriores en pantalla, el cambio no salta.
+    placeholderData: keepPreviousData,
+    queryKey: computed(() => [...baseKey.value, query.value]),
+    // La consulta forma parte de la clave: otra página u otro filtro es otra
+    // consulta, y así cada una se cachea por separado.
+    queryFn: () => options.list(query.value)
+  });
+  const items = computed(() => data.value?.data ?? []);
+  const total = computed(() => data.value?.total ?? 0);
+  const failure = computed(() => isError.value ? { retry: () => void refetch() } : void 0);
+  function invalidate() {
+    void queryClient.invalidateQueries({ queryKey: baseKey.value });
+  }
+  const formOpen = ref(false);
+  const editing = shallowRef(null);
+  const state = ref(options.emptyForm());
+  const save = useMutation({
+    onError: (error) => {
+      toast.add({ color: "error", description: describe(error), title: editing.value ? text.value.updateFailed : text.value.createFailed });
+    },
+    onSuccess: (result) => {
+      invalidate();
+      formOpen.value = false;
+      toast.add({ color: "success", title: result === "updated" ? text.value.updated : text.value.created });
+    },
+    mutationFn: async (form) => {
+      const row = editing.value;
+      if (row && options.update) {
+        await options.update(getPath(row, rowKey), form);
+        return "updated";
+      }
+      if (options.create) await options.create(form);
+      return "created";
+    }
+  });
+  function openCreate() {
+    editing.value = null;
+    state.value = options.emptyForm();
+    formOpen.value = true;
+  }
+  function openEdit(row) {
+    editing.value = row;
+    state.value = options.toForm ? options.toForm(row) : { ...row };
+    formOpen.value = true;
+  }
+  const confirmOpen = ref(false);
+  const deleting = shallowRef(null);
+  const remove = useMutation({
+    onError: (error) => {
+      toast.add({ color: "error", description: describe(error), title: text.value.deleteFailed });
+    },
+    onSuccess: () => {
+      invalidate();
+      confirmOpen.value = false;
+      deleting.value = null;
+      toast.add({ color: "success", title: text.value.deleted });
+    },
+    mutationFn: async (row) => {
+      if (options.remove) await options.remove(row);
+    }
+  });
+  function askDelete(row) {
+    deleting.value = row;
+    confirmOpen.value = true;
+  }
+  function confirmDelete() {
+    if (deleting.value) remove.mutate(deleting.value);
+  }
+  return {
+    askDelete,
+    confirmDelete,
+    confirmOpen,
+    deleting,
+    editing,
+    failure,
+    formOpen,
+    invalidate,
+    isDeleting: remove.isPending,
+    isPending,
+    isSaving: save.isPending,
+    items,
+    openCreate,
+    openEdit,
+    query,
+    refetch,
+    state,
+    total,
+    submit: () => save.mutate(state.value)
+  };
+}
+function describe(error) {
+  return error instanceof Error ? error.message : void 0;
+}

package/dist/runtime/app/composables/useVunoField.d.ts

@@ -0,0 +1,10 @@
+import { type MaybeRefOrGetter } from 'vue';
+export declare function useVunoField<TValue = unknown>(name: MaybeRefOrGetter<string>): {
+    name: import("vue").ComputedRef<string>;
+    dirty: import("vue").ComputedRef<boolean>;
+    reset: () => void;
+    setTouched: (touched?: boolean) => void;
+    setValue: (newValue: TValue) => void;
+    touched: import("vue").ComputedRef<boolean>;
+    value: import("vue").WritableComputedRef<TValue | undefined, TValue | undefined>;
+};

package/dist/runtime/app/composables/useVunoField.js

@@ -0,0 +1,34 @@
+import { computed, toValue } from "vue";
+import { useVunoForm } from "./useVunoForm.js";
+export function useVunoField(name) {
+  const form = useVunoForm();
+  const resolvedName = computed(() => toValue(name));
+  const value = computed({
+    get() {
+      return form.getValue(resolvedName.value);
+    },
+    set(newValue) {
+      form.setValue(resolvedName.value, newValue);
+    }
+  });
+  const dirty = computed(() => form.isDirty(resolvedName.value));
+  const touched = computed(() => form.isTouched(resolvedName.value));
+  function reset() {
+    form.resetField(resolvedName.value);
+  }
+  function setTouched(touched2 = true) {
+    form.setTouched(resolvedName.value, touched2);
+  }
+  function setValue(newValue) {
+    value.value = newValue;
+  }
+  return {
+    name: resolvedName,
+    dirty,
+    reset,
+    setTouched,
+    setValue,
+    touched,
+    value
+  };
+}

package/dist/runtime/app/composables/useVunoForm.d.ts

@@ -0,0 +1,2 @@
+import type { VunoFormContext, VunoFormState } from '#vuno/types/form';
+export declare function useVunoForm<TState extends VunoFormState = VunoFormState>(): VunoFormContext<TState>;

package/dist/runtime/app/composables/useVunoForm.js

@@ -0,0 +1,9 @@
+import { inject } from "vue";
+import { vunoFormInjectionKey } from "#vuno/types/form";
+export function useVunoForm() {
+  const form = inject(vunoFormInjectionKey, null);
+  if (!form) {
+    throw new Error("[Vuno] useVunoForm() debe utilizarse dentro de <VForm>.");
+  }
+  return form;
+}

package/dist/runtime/app/composables/useVunoTableQuery.d.ts

@@ -0,0 +1,51 @@
+import { type Ref } from 'vue';
+import type { VunoTableFilters, VunoTableQuery, VunoTableSort } from '#vuno/types/table';
+export type VunoTableQueryOptions = {
+    /**
+     * Nombres de los filtros que viajan en la URL. Hace falta declararlos
+     * porque al arrancar sin valores no habría forma de saber cuáles leer.
+     */
+    filterKeys?: string[];
+    filters?: VunoTableFilters;
+    /**
+     * Cómo se escribe en el historial del navegador.
+     *
+     * - `replace` (por defecto): no deja rastro. Recargar y compartir el
+     *   enlace funcionan, pero el botón atrás sale de la página en vez de
+     *   deshacer el último filtro.
+     * - `push`: cada cambio es una entrada, así que atrás deshace filtro a
+     *   filtro. A cambio, teclear en el buscador llena el historial —el
+     *   antirrebote de la tabla lo suaviza, pero no lo evita.
+     */
+    history?: 'push' | 'replace';
+    page?: number;
+    pageSize?: number;
+    /** Prefijo de los parámetros, para tener varias tablas en la misma página. */
+    prefix?: string;
+    search?: string;
+    /**
+     * Orden inicial de la tabla. Admite la forma corta `'sku'` (ascendente).
+     *
+     * Declararlo cambia el ciclo de la cabecera: en vez de asc → desc → sin
+     * orden, el tercer clic devuelve a este orden.
+     *
+     * Va aquí y no en la definición porque el primer `fetch` —el del servidor
+     * incluido— tiene que salir ya ordenado; aplicarlo al montar la tabla
+     * provocaría una segunda petición y un parpadeo.
+     */
+    sort?: null | string | VunoTableSort;
+    /**
+     * Guarda el estado en la query string: el enlace es compartible y recargar
+     * conserva los filtros. Si además quieres que el botón atrás los deshaga,
+     * usa `history: 'push'`.
+     */
+    url?: boolean;
+};
+/**
+ * Estado de consulta para `<VTable v-model:query>`.
+ *
+ * Sin `url` es un `ref` normal. Con `url: true` se sincroniza en los dos
+ * sentidos con la query string, de modo que navegar atrás o pegar el enlace
+ * en otra pestaña reproduce la misma vista.
+ */
+export declare function useVunoTableQuery(options?: VunoTableQueryOptions): Ref<VunoTableQuery>;

package/dist/runtime/app/composables/useVunoTableQuery.js

@@ -0,0 +1,110 @@
+import { computed, ref, watch } from "vue";
+import { useRoute, useRouter } from "#imports";
+export function useVunoTableQuery(options = {}) {
+  const defaults = {
+    filters: options.filters ?? {},
+    page: options.page ?? 1,
+    pageSize: options.pageSize ?? 10,
+    search: options.search ?? "",
+    sort: typeof options.sort === "string" ? { column: options.sort, direction: "asc" } : options.sort ?? null
+  };
+  const normalize = (value) => ({ ...value, sort: value.sort ?? defaults.sort });
+  if (!options.url) {
+    const local = ref({ ...defaults });
+    return computed({
+      get: () => local.value,
+      set: (value) => {
+        local.value = normalize(value);
+      }
+    });
+  }
+  const route = useRoute();
+  const router = useRouter();
+  const prefix = options.prefix ?? "";
+  const keys = {
+    direction: `${prefix}direction`,
+    page: `${prefix}page`,
+    pageSize: `${prefix}pageSize`,
+    search: `${prefix}search`,
+    sort: `${prefix}sort`
+  };
+  const filterKeys = options.filterKeys ?? Object.keys(defaults.filters);
+  const readFilters = () => {
+    const filters = { ...defaults.filters };
+    for (const key of filterKeys) {
+      const raw = route.query[`${prefix}${key}`];
+      if (raw === void 0) {
+        delete filters[key];
+        continue;
+      }
+      const value = readString(raw, "");
+      filters[key] = value === "true" ? true : value === "false" ? false : value;
+    }
+    return filters;
+  };
+  const fromRoute = () => {
+    const column = readString(route.query[keys.sort], "");
+    return {
+      filters: readFilters(),
+      page: readNumber(route.query[keys.page], defaults.page),
+      pageSize: readNumber(route.query[keys.pageSize], defaults.pageSize),
+      search: readString(route.query[keys.search], defaults.search),
+      // Sin parámetro se cae al orden por defecto.
+      sort: column ? { column, direction: readString(route.query[keys.direction], "asc") === "desc" ? "desc" : "asc" } : defaults.sort
+    };
+  };
+  const state = ref(fromRoute());
+  const toRouteQuery = (value) => {
+    const next = { ...route.query };
+    next[keys.page] = value.page === defaults.page ? void 0 : String(value.page);
+    next[keys.pageSize] = value.pageSize === defaults.pageSize ? void 0 : String(value.pageSize);
+    next[keys.search] = value.search === "" ? void 0 : value.search;
+    const esElOrdenPorDefecto = value.sort?.column === defaults.sort?.column && value.sort?.direction === defaults.sort?.direction;
+    if (esElOrdenPorDefecto) {
+      next[keys.sort] = void 0;
+      next[keys.direction] = void 0;
+    } else if (value.sort) {
+      next[keys.sort] = value.sort.column;
+      next[keys.direction] = value.sort.direction;
+    } else {
+      next[keys.sort] = void 0;
+      next[keys.direction] = void 0;
+    }
+    for (const key of filterKeys) {
+      const filter = value.filters[key];
+      next[`${prefix}${key}`] = filter === void 0 || filter === null || filter === "" ? void 0 : String(filter);
+    }
+    for (const key of Object.keys(next)) {
+      if (next[key] === void 0) delete next[key];
+    }
+    return next;
+  };
+  const serialized = computed(() => JSON.stringify(toRouteQuery(state.value)));
+  watch(serialized, () => {
+    const to = { query: toRouteQuery(state.value) };
+    void (options.history === "push" ? router.push(to) : router.replace(to));
+  });
+  watch(
+    () => route.query,
+    () => {
+      const next = fromRoute();
+      if (JSON.stringify(next) !== JSON.stringify(state.value)) {
+        state.value = next;
+      }
+    }
+  );
+  return computed({
+    get: () => state.value,
+    set: (value) => {
+      state.value = normalize(value);
+    }
+  });
+}
+function readNumber(value, fallback) {
+  const parsed = Number(Array.isArray(value) ? value[0] : value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function readString(value, fallback) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  return typeof raw === "string" ? raw : fallback;
+}

package/dist/runtime/app/composables/useVunoTheme.d.ts

@@ -0,0 +1,12 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { VunoFieldSlots } from '#vuno/types/field';
+import type { VunoIcons, VunoMessages, VunoThemeKey } from '#vuno/types/theme';
+/**
+ * Resuelve las clases de un componente del módulo.
+ *
+ * @param key Clave del tema (`fieldText`, `form`, ...).
+ * @param ui Override de la instancia, normalmente `props.ui`.
+ */
+export declare function useVunoTheme(key: VunoThemeKey, ui?: MaybeRefOrGetter<undefined | VunoFieldSlots>): ComputedRef<VunoFieldSlots>;
+export declare function useVunoIcons(): ComputedRef<VunoIcons>;
+export declare function useVunoMessages(): ComputedRef<VunoMessages>;

package/dist/runtime/app/composables/useVunoTheme.js

@@ -0,0 +1,35 @@
+import { computed, toValue } from "vue";
+import { useAppConfig } from "#imports";
+import { defaultIcons, defaultMessages, defaultTheme } from "#vuno/theme";
+export function useVunoTheme(key, ui) {
+  const vuno = useVunoAppConfig();
+  return computed(() => mergeSlots(defaultTheme[key]?.slots, vuno.value[key]?.slots, toValue(ui)));
+}
+export function useVunoIcons() {
+  const vuno = useVunoAppConfig();
+  return computed(() => ({ ...defaultIcons, ...vuno.value.icons }));
+}
+export function useVunoMessages() {
+  const vuno = useVunoAppConfig();
+  return computed(() => ({ ...defaultMessages, ...vuno.value.messages }));
+}
+function toClassString(value) {
+  if (!value) return "";
+  return Array.isArray(value) ? value.filter(Boolean).join(" ") : value;
+}
+function mergeSlots(...sources) {
+  const merged = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const [slot, value] of Object.entries(source)) {
+      const className = toClassString(value);
+      if (!className) continue;
+      merged[slot] = merged[slot] ? `${merged[slot]} ${className}` : className;
+    }
+  }
+  return merged;
+}
+function useVunoAppConfig() {
+  const appConfig = useAppConfig();
+  return computed(() => appConfig.vuno ?? {});
+}

package/dist/runtime/app/theme/index.d.ts

@@ -0,0 +1,14 @@
+import type { VunoIcons, VunoMessages, VunoThemeConfig } from '#vuno/types/theme';
+/**
+ * Tema por defecto. Solo aporta geometría (ancho, grid, espaciado) y
+ * utilidades semánticas de Nuxt UI; ningún color, radio ni tipografía
+ * literal, de modo que el proyecto que consume el módulo sigue mandando
+ * a través de `ui.colors`, `--ui-radius` y compañía.
+ *
+ * Las claves `field*` describen los slots del componente de Nuxt UI que
+ * cada campo envuelve. El `w-full` es deliberado y no opcional por diseño:
+ * el ancho de un campo lo decide el grid de `utils/grid`, nunca el campo.
+ */
+export declare const defaultTheme: Required<VunoThemeConfig>;
+export declare const defaultIcons: VunoIcons;
+export declare const defaultMessages: VunoMessages;