@groupteknology/vuno 1.0.0 → 2.0.0

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

@@ -0,0 +1,29 @@
+import { computed, toValue } from "vue";
+import { useAppConfig } from "#imports";
+import { defaultIcons, defaultMessages, defaultTheme } from "#vuno/theme";
+import { mergeSlots, selectCompoundVariants, selectVariants } from "#vuno/utils/theme";
+export function useTheme(key, ui, variants) {
+  const vuno = useVunoAppConfig();
+  const entry = (source) => source[key];
+  return computed(() => {
+    const active = toValue(variants);
+    const merged = mergeSlots(entry(defaultTheme)?.slots, ...selectVariants(entry(defaultTheme)?.variants, active), ...selectCompoundVariants(entry(defaultTheme)?.compoundVariants, active), entry(vuno.value)?.slots, ...selectVariants(entry(vuno.value)?.variants, active), ...selectCompoundVariants(entry(vuno.value)?.compoundVariants, active), toValue(ui));
+    return merged;
+  });
+}
+export function useIcons() {
+  const vuno = useVunoAppConfig();
+  return computed(() => ({ ...defaultIcons, ...vuno.value.icons }));
+}
+export function useLocale() {
+  const vuno = useVunoAppConfig();
+  return computed(() => vuno.value.locale ?? "es");
+}
+export function useMessages() {
+  const vuno = useVunoAppConfig();
+  return computed(() => ({ ...defaultMessages, ...vuno.value.messages }));
+}
+function useVunoAppConfig() {
+  const appConfig = useAppConfig();
+  return computed(() => appConfig.vuno ?? {});
+}

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

@@ -0,0 +1,28 @@
+import type { VunoNotifyRequest } from '#vuno/types/app';
+/**
+ * Avisos que no interrumpen.
+ *
+ * ```ts
+ * const toast = useToast()
+ * toast.success({ title: 'Producto guardado' })
+ * ```
+ *
+ * `notify` devuelve el identificador para poder cerrarla antes de tiempo, que
+ * es lo que permite una fija mientras algo tarda:
+ *
+ * ```ts
+ * const id = toast.notify({ title: 'Subiendo…', duration: 0 })
+ * await subir()
+ * toast.dismiss(id)
+ * ```
+ *
+ * Para lo que no se puede pasar por alto está `alert()`, que sí bloquea.
+ */
+export declare function useToast(): {
+    dismiss: (id: number) => void;
+    error: (request: Omit<VunoNotifyRequest, "color">) => number;
+    info: (request: Omit<VunoNotifyRequest, "color">) => number;
+    notify: (request: VunoNotifyRequest) => number;
+    success: (request: Omit<VunoNotifyRequest, "color">) => number;
+    warning: (request: Omit<VunoNotifyRequest, "color">) => number;
+};

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

@@ -0,0 +1,13 @@
+import { useContext } from "./useContext.js";
+export function useToast() {
+  const context = useContext();
+  const withColor = (color) => (request) => context.notify({ ...request, color });
+  return {
+    dismiss: context.dismiss,
+    error: withColor("error"),
+    info: withColor("info"),
+    notify: context.notify,
+    success: withColor("success"),
+    warning: withColor("warning")
+  };
+}

package/dist/runtime/app/internal/keys.d.ts

@@ -0,0 +1,43 @@
+import type { InjectionKey } from 'vue';
+import type { VunoContext } from '#vuno/types/app';
+import type { VunoFormContext } from '#vuno/types/form';
+/**
+ * Las claves de inyección del módulo.
+ *
+ * Viven aquí y no en `composables/` porque `addImportsDir` escanea **exports**:
+ * una constante exportada desde ahí acaba en el espacio global de todo proyecto
+ * que instale vuno, y `vunoContextInjectionKey` lo estaba. Nadie la escribe —el
+ * módulo la usa por ruta— así que ser global no le aportaba nada y sí ocupaba un
+ * nombre ajeno para siempre.
+ *
+ * Y no en `types/` porque son **valores**, no tipos: un `Symbol` en la carpeta de
+ * los tipos es de esas cosas que confunden al siguiente que abra el árbol.
+ */
+export declare const vunoContextInjectionKey: InjectionKey<VunoContext>;
+/** Si el modal pertenece a la pila global pero ya no es el que está arriba. */
+export declare const vunoOverlayBehindInjectionKey: InjectionKey<() => boolean>;
+export declare const vunoFormInjectionKey: InjectionKey<VunoFormContext>;
+/**
+ * Las ramas abiertas de una navegación anidada.
+ *
+ * El componente se recursa, así que el estado tiene que vivir en la instancia de
+ * fuera y heredarse: un `Set` por nivel dejaría cada uno abriéndose por su
+ * cuenta. La de fuera se reconoce por no encontrar nada inyectado.
+ */
+export declare const vunoNavigationListInjectionKey: InjectionKey<Set<string>>;
+/** Cierres diferidos compartidos por todos los paneles de un navbar. */
+export declare const vunoNavigationMenuCloseInjectionKey: InjectionKey<Set<ReturnType<typeof setTimeout>>>;
+/** Ramas abiertas compartidas por todos los niveles del menú flotante. */
+export declare const vunoNavigationMenuOpenInjectionKey: InjectionKey<Set<string>>;
+/** Ramas fijadas por clic: no se cierran al abandonar el disparador. */
+export declare const vunoNavigationMenuPinnedInjectionKey: InjectionKey<Set<string>>;
+/**
+ * La dirección de lectura, que la provee `VApp`.
+ *
+ * Importa en un sitio muy concreto y nada evidente: **las flechas de una lista
+ * de pestañas**. En árabe,
+ * la flecha derecha va a la pestaña anterior, no a la siguiente, y quien no lee
+ * en árabe no lo descubre probando. El CSS del módulo no la necesita porque usa
+ * propiedades lógicas.
+ */
+export declare const vunoDirectionInjectionKey: InjectionKey<() => 'ltr' | 'rtl'>;

package/dist/runtime/app/internal/keys.js

@@ -0,0 +1,8 @@
+export const vunoContextInjectionKey = Symbol("vuno-context");
+export const vunoOverlayBehindInjectionKey = Symbol("vuno-overlay-behind");
+export const vunoFormInjectionKey = Symbol("vuno-form");
+export const vunoNavigationListInjectionKey = Symbol("vuno-navigation-list");
+export const vunoNavigationMenuCloseInjectionKey = Symbol("vuno-navigation-menu-close");
+export const vunoNavigationMenuOpenInjectionKey = Symbol("vuno-navigation-menu-open");
+export const vunoNavigationMenuPinnedInjectionKey = Symbol("vuno-navigation-menu-pinned");
+export const vunoDirectionInjectionKey = Symbol("vuno-direction");

package/dist/runtime/app/internal/slots.d.ts

@@ -0,0 +1,22 @@
+import type { VNode } from 'vue';
+/** Primer elemento renderizable de un slot, atravesando fragmentos. */
+export declare function firstElement(nodes?: unknown): undefined | VNode;
+/**
+ * ¿Este slot **produce** algo, o solo está declarado?
+ *
+ * No es lo mismo, y la diferencia solo aparece cuando un componente compone a
+ * otro. Mientras una tarjeta la escribe una persona a mano, `slots.header` es
+ * cierto exactamente cuando hay cabecera. En cuanto otro componente la envuelve
+ * —el modal, que siempre declara sus tres slots y a veces no tiene título— la
+ * declaración deja de significar contenido, y aparece una franja vacía con su
+ * relleno y su línea divisoria: se ve raro, no falla, y nadie sabe nombrarla.
+ *
+ * Baja por los fragmentos, que es la mitad que cuesta. Un `<template>` con un
+ * `v-if` falso no devuelve el comentario a secas: devuelve un fragmento que lo
+ * contiene, así que mirar solo el primer nivel cuenta ese fragmento como
+ * contenido. La primera versión de esto se equivocaba justo ahí.
+ *
+ * Vive en `internal/` porque es una utilidad y no un composable: como global
+ * pisaría cualquier `filled` del proyecto que instale el módulo.
+ */
+export declare function filled(slot?: () => unknown): boolean;

package/dist/runtime/app/internal/slots.js

@@ -0,0 +1,24 @@
+import { Comment, Fragment, Text } from "vue";
+export function firstElement(nodes) {
+  if (!Array.isArray(nodes)) return;
+  for (const node of nodes) {
+    if (node.type === Comment || node.type === Text) continue;
+    if (node.type === Fragment) {
+      const inner = firstElement(node.children);
+      if (inner) return inner;
+      continue;
+    }
+    return node;
+  }
+}
+export function filled(slot) {
+  return hasContent(slot?.());
+}
+function hasContent(nodes) {
+  return (nodes ?? []).some((node) => {
+    if (node.type === Comment) return false;
+    if (node.type === Text) return String(node.children ?? "").trim().length > 0;
+    if (Array.isArray(node.children)) return hasContent(node.children);
+    return true;
+  });
+}

package/dist/runtime/app/plugins/vue-query.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cliente de consultas por aplicación y por petición SSR.
+ *
+ * El estado resuelto en servidor viaja en el payload de Nuxt para que el
+ * cliente hidrate la misma caché en vez de repetir la primera consulta.
+ */
+declare const _default: import("#app/nuxt").Plugin<Record<string, unknown>> & import("#app/nuxt").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/app/plugins/vue-query.js

@@ -0,0 +1,13 @@
+import { dehydrate, hydrate, QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
+import { defineNuxtPlugin, useState } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  const state = useState("vuno:vue-query", () => null);
+  const queryClient = new QueryClient();
+  nuxtApp.vueApp.use(VueQueryPlugin, { queryClient });
+  if (import.meta.server) {
+    nuxtApp.hooks.hook("app:rendered", () => {
+      state.value = dehydrate(queryClient);
+    });
+  }
+  if (import.meta.client && state.value) hydrate(queryClient, state.value);
+});

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

@@ -0,0 +1,2 @@
+import type { VunoIcons } from '#vuno/types/theme';
+export declare const defaultIcons: VunoIcons;

package/dist/runtime/app/theme/icons.js

@@ -0,0 +1,43 @@
+export const defaultIcons = {
+  actions: "lucide:ellipsis-vertical",
+  addItem: "lucide:plus",
+  booleanFalse: "lucide:minus",
+  booleanTrue: "lucide:check",
+  breadcrumbSeparator: "lucide:chevron-right",
+  clearSearch: "lucide:x",
+  close: "lucide:x",
+  codeCopied: "lucide:check",
+  codeCopy: "lucide:copy",
+  confirm: "lucide:triangle-alert",
+  empty: "lucide:inbox",
+  failure: "lucide:triangle-alert",
+  fileMoveDown: "lucide:chevron-down",
+  fileMoveUp: "lucide:chevron-up",
+  fileRemove: "lucide:x",
+  fileUpload: "lucide:image",
+  filter: "lucide:list-filter",
+  navigationToggle: "lucide:chevron-right",
+  noMatches: "lucide:search-x",
+  notifyError: "lucide:circle-x",
+  notifyInfo: "lucide:info",
+  notifySuccess: "lucide:circle-check",
+  notifyWarning: "lucide:triangle-alert",
+  numberDecrement: "lucide:minus",
+  numberIncrement: "lucide:plus",
+  paginationFirst: "lucide:chevrons-left",
+  paginationLast: "lucide:chevrons-right",
+  paginationNext: "lucide:chevron-right",
+  paginationPrevious: "lucide:chevron-left",
+  passwordHide: "lucide:eye-off",
+  passwordShow: "lucide:eye",
+  removeItem: "lucide:trash-2",
+  retry: "lucide:refresh-cw",
+  search: "lucide:search",
+  selectOpen: "lucide:chevron-down",
+  selectSelected: "lucide:check",
+  slugEdit: "lucide:pencil",
+  slugReset: "lucide:x",
+  sort: "lucide:chevrons-up-down",
+  sortAsc: "lucide:arrow-up",
+  sortDesc: "lucide:arrow-down"
+};