@groupteknology/vuno 1.0.0 → 2.0.0

package/dist/runtime/app/utils/path.d.ts

@@ -0,0 +1,16 @@
+export declare function parsePath(path: string): string[];
+export declare function getPath<T = unknown>(object: unknown, path: string): T | undefined;
+export declare function setPath(object: object, path: string, value: unknown): void;
+/**
+ * Clon profundo que preserva la referencia de los `File`/`Blob` en lugar de
+ * duplicarlos, para que comparar el estado inicial con el actual siga siendo
+ * fiable. `structuredClone` no sirve aquí: duplica cada `File` y revienta con
+ * valores no clonables.
+ */
+export declare function cloneValue<T>(value: T): T;
+/**
+ * Comparación estructural. Los binarios se comparan por identidad, que es lo
+ * que permite detectar que una galería cambió de orden o de contenido —algo
+ * que una comparación por JSON no ve, porque un `File` serializa a `{}`.
+ */
+export declare function isEqual(first: unknown, second: unknown): boolean;

package/dist/runtime/app/utils/path.js

@@ -0,0 +1,76 @@
+const unsafePathKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+export function parsePath(path) {
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+}
+export function getPath(object, path) {
+  const keys = parsePath(path);
+  if (keys.some((key) => unsafePathKeys.has(key))) return void 0;
+  let current = object;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = Object.hasOwn(current, key) ? current[key] : void 0;
+  }
+  return current;
+}
+export function setPath(object, path, value) {
+  const keys = parsePath(path);
+  if (keys.length === 0 || keys.some((key) => unsafePathKeys.has(key))) {
+    return;
+  }
+  let current = object;
+  for (let index = 0; index < keys.length - 1; index++) {
+    const key = keys[index];
+    const nextKey = keys[index + 1];
+    const nextIsArrayIndex = /^\d+$/.test(nextKey);
+    let next = current[key];
+    if (next === void 0 || next === null || typeof next !== "object") {
+      next = nextIsArrayIndex ? [] : {};
+      current[key] = next;
+    }
+    current = next;
+  }
+  const lastKey = keys.at(-1);
+  current[lastKey] = value;
+}
+export function cloneValue(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (isBinary(value)) return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = cloneValue(item);
+    }
+    return result;
+  }
+  return value;
+}
+export function isEqual(first, second) {
+  if (first === second) return true;
+  if (first instanceof Date && second instanceof Date) {
+    return first.getTime() === second.getTime();
+  }
+  if (isBinary(first) || isBinary(second)) return false;
+  if (Array.isArray(first) && Array.isArray(second)) {
+    return first.length === second.length && first.every((item, index) => isEqual(item, second[index]));
+  }
+  if (isPlainObject(first) && isPlainObject(second)) {
+    const firstKeys = Object.keys(first);
+    const secondKeys = Object.keys(second);
+    if (firstKeys.length !== secondKeys.length) return false;
+    return firstKeys.every((key) => Object.hasOwn(second, key) && isEqual(first[key], second[key]));
+  }
+  return false;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isBinary(value) {
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  return typeof File !== "undefined" && value instanceof File;
+}

package/dist/runtime/app/utils/query-key.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Clave base de la caché ya resuelta.
+ *
+ * `ready` en `false` significa que la clave todavía no se puede construir
+ * —falta la empresa, la tienda o el almacén que la pantalla está resolviendo—
+ * y que la consulta no debe dispararse.
+ */
+export type VunoResolvedKey = {
+    ready: boolean;
+    segments: readonly unknown[];
+};
+/**
+ * Normaliza la clave base a segmentos y dice si está completa.
+ *
+ * Un segmento `undefined` o `null` marca la clave como no lista. En una clave
+ * de caché ese hueco nunca es un valor: es un dato que aún no ha llegado, y
+ * consultar con él devolvería la lista de otro inquilino o una vacía. Tratarlo
+ * como «todavía no» evita que cada pantalla repita su propio `enabled`.
+ */
+export declare function resolveQueryKey(key: null | readonly unknown[] | string | undefined): VunoResolvedKey;

package/dist/runtime/app/utils/query-key.js

@@ -0,0 +1,7 @@
+export function resolveQueryKey(key) {
+  if (key === null || key === void 0) return { ready: false, segments: [] };
+  const segments = Array.isArray(key) ? key : [key];
+  if (segments.length === 0) return { ready: false, segments };
+  const complete = segments.every((segment) => segment !== null && segment !== void 0);
+  return { ready: complete, segments };
+}

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

@@ -0,0 +1,44 @@
+import { type ClassValue } from 'clsx';
+import type { VunoSlots } from '#vuno/types/base';
+import type { VunoThemeCompoundVariant, VunoThemeEntry, VunoThemeKey, VunoThemeVariants } from '#vuno/types/theme';
+/**
+ * Los slots de las variantes activas.
+ *
+ * **El orden en que se devuelven es el de declaración**, y ese orden decide
+ * quién gana cuando dos dimensiones escriben el mismo slot. No es de fiar:
+ * perfectionist ordena las claves alfabéticamente, así que renombrar una
+ * dimensión puede cambiar el resultado sin que nadie lo relacione. Si una
+ * dimensión tiene que ganar a otra, que publique una variable y la otra la
+ * consuma, en lugar de confiar en quién funde después.
+ */
+export declare function selectVariants(variants: undefined | VunoThemeVariants, active: Record<string, string | undefined> | undefined): (undefined | VunoSlots)[];
+/**
+ * Las combinaciones que se cumplen enteras.
+ *
+ * Todas sus condiciones o ninguna: una entrada con `color` y `variant` solo
+ * entra si las dos coinciden con lo activo. Una condición cuya dimensión no
+ * esté activa **no** cuenta como cumplida, que es lo que evita que una
+ * combinación se cuele en un componente que ni declara esa variante.
+ *
+ * Se aplican después de `selectVariants` del mismo nivel, y ese orden es lo que
+ * las hace útiles: lo específico llega al final y gana el conflicto.
+ */
+export declare function selectCompoundVariants(compounds: undefined | VunoThemeCompoundVariant[], active: Record<string, string | undefined> | undefined): (undefined | VunoSlots)[];
+/** Une un slot escrito como array en una sola cadena, descartando lo vacío. */
+export declare function toClassString(value: string | string[] | undefined): string;
+/**
+ * Funde slots en orden de prioridad creciente: tema → app.config → prop.
+ *
+ * Resuelve los conflictos con `tailwind-merge`, y eso no siempre fue así: antes
+ * se concatenaba y se confiaba en que lo hiciera Nuxt UI al recibir el resultado
+ * por su prop `ui`. Con componentes propios —que solo escriben las clases en el
+ * elemento— esa red desapareció, y un `max-w-lg` del tema convivía con el
+ * `max-w-3xl` de quien lo sobreescribía: ganaba el que Tailwind hubiera puesto
+ * más tarde en la hoja, no el más específico.
+ */
+export declare function mergeSlots(...sources: (undefined | VunoSlots)[]): Record<string, string | undefined>;
+/** Compone clases condicionales y resuelve conflictos de Tailwind de izquierda a derecha. */
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function twObj<T extends Record<string, string>>(obj: T): T;
+/** Define una sola entrada de tema y conserva sus slots y variantes literales. */
+export declare function defineTheme<const TKey extends VunoThemeKey, const TEntry extends VunoThemeEntry>(key: TKey, entry: TEntry): Record<TKey, TEntry>;

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

@@ -0,0 +1,43 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function selectVariants(variants, active) {
+  if (!variants || !active) return [];
+  return Object.entries(variants).map(([dimension, values]) => {
+    const chosen = active[dimension];
+    return chosen === void 0 ? void 0 : values[chosen];
+  });
+}
+export function selectCompoundVariants(compounds, active) {
+  if (!compounds || !active) return [];
+  return compounds.filter(
+    (compound) => Object.entries(compound).every(([dimension, expected]) => {
+      if (dimension === "class") return true;
+      return active[dimension] === expected;
+    })
+  ).map((compound) => compound.class);
+}
+export function toClassString(value) {
+  if (!value) return "";
+  return Array.isArray(value) ? value.filter(Boolean).join(" ") : value;
+}
+export 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] ? twMerge(merged[slot], className) : className;
+    }
+  }
+  return merged;
+}
+export function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+export function twObj(obj) {
+  return obj;
+}
+export function defineTheme(key, entry) {
+  return { [key]: entry };
+}

package/dist/types.d.mts

@@ -1,13 +1,5 @@
-import type { ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module.mjs'
+export { default } from './module.mjs'
 
-declare module '#app' {
-  interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
-}
+export { type ModuleOptions } from './module.mjs'
 
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
-}
-
-export * from "./module.mjs"
+export * from '../dist/runtime/app/types/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groupteknology/vuno",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Formularios, tablas y diálogos declarativos para Nuxt 4, con componentes propios y tokens sobreescribibles.",
   "keywords": [
     "nuxt",
@@ -29,6 +29,14 @@
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
     },
+    "./composables/defineShortcuts": {
+      "types": "./dist/runtime/app/composables/defineShortcuts.d.ts",
+      "import": "./dist/runtime/app/composables/defineShortcuts.js"
+    },
+    "./composables/use*": {
+      "types": "./dist/runtime/app/composables/use*.d.ts",
+      "import": "./dist/runtime/app/composables/use*.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/module.mjs",
@@ -36,6 +44,12 @@
     "*": {
       ".": [
         "./dist/types.d.mts"
+      ],
+      "composables/defineShortcuts": [
+        "./dist/runtime/app/composables/defineShortcuts.d.ts"
+      ],
+      "composables/use*": [
+        "./dist/runtime/app/composables/use*.d.ts"
       ]
     }
   },
@@ -44,11 +58,12 @@
   ],
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@vueuse/core": "^15.0.0",
     "@iconify-json/lucide": "^1.2.134",
     "@nuxt/icon": "^2.5.1",
     "@nuxt/kit": "^4.5.2",
     "@tailwindcss/vite": "^4.3.3",
+    "@tanstack/vue-query": "^5.102.8",
+    "clsx": "^2.1.1",
     "gsap": "^3.15.0",
     "tailwind-merge": "^3.7.0",
     "tailwindcss": "^4.3.3"
@@ -56,7 +71,7 @@
   "devDependencies": {
     "@nuxt/module-builder": "^1.0.3",
     "@nuxt/schema": "^4.5.2",
-    "@tanstack/vue-query": "^5.0.0",
+    "@nuxt/test-utils": "^4.3.2",
     "@types/node": "^26.6.2",
     "@vitejs/plugin-vue": "^6.0.9",
     "@vitest/coverage-v8": "^5.0.1",

package/dist/module.d.cts

@@ -1,2 +0,0 @@
-export * from "/woodpecker/src/github.com/groupteknology/vuno/packages/core/src/module.js";
-export { default } from "/woodpecker/src/github.com/groupteknology/vuno/packages/core/src/module.js";