@groupteknology/vuno 0.1.0

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

@@ -0,0 +1,77 @@
+import type { VunoFieldSlots, VunoFieldType } from './field.js';
+/**
+ * Claves tematizables. Cada `field*` describe los slots del componente de
+ * Nuxt UI que ese campo envuelve, así que los nombres de slot son los del
+ * componente subyacente (`root`, `base`, `trailing`, ...).
+ */
+export type VunoThemeKey = 'confirm' | 'form' | 'formField' | 'formModal' | 'formSection' | 'page' | 'state' | 'table' | `field${Capitalize<VunoFieldType>}`;
+export type VunoThemeEntry = {
+    slots?: VunoFieldSlots;
+};
+export type VunoThemeConfig = {
+    [TKey in VunoThemeKey]?: VunoThemeEntry;
+};
+export type VunoIcons = {
+    actions: string;
+    addItem: string;
+    clearSearch: string;
+    confirm: string;
+    empty: string;
+    failure: string;
+    fileMoveDown: string;
+    fileMoveUp: string;
+    fileRemove: string;
+    fileUpload: string;
+    filter: string;
+    removeItem: string;
+    retry: string;
+    search: string;
+    slugEdit: string;
+    slugReset: string;
+    sort: string;
+    sortAsc: string;
+    sortDesc: string;
+};
+export type VunoMessages = {
+    addItem: string;
+    applyFilters: string;
+    cancel: string;
+    clearFilters: string;
+    clearSearch: string;
+    clearSelection: string;
+    confirm: string;
+    confirmDescription: string;
+    confirmTitle: string;
+    created: string;
+    deleted: string;
+    deleteFailed: string;
+    emptyArray: string;
+    emptyHint: string;
+    emptyTable: string;
+    failureHint: string;
+    failureTitle: string;
+    fileMoveDown: string;
+    fileMoveUp: string;
+    fileRemove: string;
+    filters: string;
+    filtersTitle: string;
+    of: string;
+    removeItem: string;
+    retry: string;
+    rowActions: string;
+    rowSelected: string;
+    rowsSelected: string;
+    save: string;
+    saveFailed: string;
+    searchPlaceholder: string;
+    selectPlaceholder: string;
+    showing: string;
+    slugEdit: string;
+    slugReset: string;
+    updated: string;
+};
+/** Forma de `app.config.ts` → `vuno`. */
+export type VunoAppConfig = VunoThemeConfig & {
+    icons?: Partial<VunoIcons>;
+    messages?: Partial<VunoMessages>;
+};

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

@@ -0,0 +1,9 @@
+export declare function formatSlug(value?: string): string;
+/**
+ * Los formateadores reciben el locale ya resuelto (el de `<UApp :locale>`), en
+ * lugar de fijar uno: qué idioma habla la aplicación lo decide el proyecto
+ * consumidor, no este paquete.
+ */
+export declare function formatNumber(value: unknown, locale?: string, decimals?: number): string;
+export declare function formatCurrency(value: unknown, locale?: string, currency?: string, decimals?: number): string;
+export declare function formatDate(value: unknown, locale?: string, options?: Intl.DateTimeFormatOptions): string;

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

@@ -0,0 +1,30 @@
+export function formatSlug(value) {
+  if (!value) return "";
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export function formatNumber(value, locale, decimals) {
+  if (value === null || value === void 0 || value === "") return "";
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) return "";
+  return new Intl.NumberFormat(locale, {
+    maximumFractionDigits: decimals ?? 2,
+    minimumFractionDigits: decimals ?? 0
+  }).format(parsed);
+}
+export function formatCurrency(value, locale, currency = "EUR", decimals) {
+  if (value === null || value === void 0 || value === "") return "";
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) return "";
+  return new Intl.NumberFormat(locale, {
+    currency,
+    maximumFractionDigits: decimals ?? 2,
+    minimumFractionDigits: decimals ?? 2,
+    style: "currency"
+  }).format(parsed);
+}
+export function formatDate(value, locale, options) {
+  if (value === null || value === void 0 || value === "") return "";
+  const date = value instanceof Date ? value : new Date(String(value));
+  if (Number.isNaN(date.getTime())) return "";
+  return new Intl.DateTimeFormat(locale, options ?? { dateStyle: "medium" }).format(date);
+}

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

@@ -0,0 +1,9 @@
+import type { VunoFieldColumns } from '#vuno/types/field';
+/**
+ * `min-w-0` acompaña siempre al `col-span`: un grid item nace con
+ * `min-width: auto`, que le impide encoger por debajo de su contenido mínimo
+ * y hace que se salga de la pista en contenedores estrechos (un modal, por
+ * ejemplo). Sin esto el ancho lo acabaría decidiendo el contenido y no el
+ * grid, que es justo lo contrario de lo que persigue el sistema de columnas.
+ */
+export declare function getColumnSpanClass(columns?: VunoFieldColumns): string[];

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

@@ -0,0 +1,91 @@
+const spanClasses = {
+  xs: {
+    1: "col-span-1",
+    2: "col-span-2",
+    3: "col-span-3",
+    4: "col-span-4",
+    5: "col-span-5",
+    6: "col-span-6",
+    7: "col-span-7",
+    8: "col-span-8",
+    9: "col-span-9",
+    10: "col-span-10",
+    11: "col-span-11",
+    12: "col-span-12"
+  },
+  sm: {
+    1: "@sm:col-span-1",
+    2: "@sm:col-span-2",
+    3: "@sm:col-span-3",
+    4: "@sm:col-span-4",
+    5: "@sm:col-span-5",
+    6: "@sm:col-span-6",
+    7: "@sm:col-span-7",
+    8: "@sm:col-span-8",
+    9: "@sm:col-span-9",
+    10: "@sm:col-span-10",
+    11: "@sm:col-span-11",
+    12: "@sm:col-span-12"
+  },
+  md: {
+    1: "@md:col-span-1",
+    2: "@md:col-span-2",
+    3: "@md:col-span-3",
+    4: "@md:col-span-4",
+    5: "@md:col-span-5",
+    6: "@md:col-span-6",
+    7: "@md:col-span-7",
+    8: "@md:col-span-8",
+    9: "@md:col-span-9",
+    10: "@md:col-span-10",
+    11: "@md:col-span-11",
+    12: "@md:col-span-12"
+  },
+  lg: {
+    1: "@lg:col-span-1",
+    2: "@lg:col-span-2",
+    3: "@lg:col-span-3",
+    4: "@lg:col-span-4",
+    5: "@lg:col-span-5",
+    6: "@lg:col-span-6",
+    7: "@lg:col-span-7",
+    8: "@lg:col-span-8",
+    9: "@lg:col-span-9",
+    10: "@lg:col-span-10",
+    11: "@lg:col-span-11",
+    12: "@lg:col-span-12"
+  },
+  xl: {
+    1: "@xl:col-span-1",
+    2: "@xl:col-span-2",
+    3: "@xl:col-span-3",
+    4: "@xl:col-span-4",
+    5: "@xl:col-span-5",
+    6: "@xl:col-span-6",
+    7: "@xl:col-span-7",
+    8: "@xl:col-span-8",
+    9: "@xl:col-span-9",
+    10: "@xl:col-span-10",
+    11: "@xl:col-span-11",
+    12: "@xl:col-span-12"
+  }
+};
+export function getColumnSpanClass(columns) {
+  if (!columns) return ["min-w-0", "col-span-12"];
+  if (typeof columns === "number") return ["min-w-0", "col-span-12", spanClasses.md[columns]];
+  const classes = ["min-w-0"];
+  classes.push(spanClasses.xs[columns.xs ?? 12]);
+  if (columns.sm) {
+    classes.push(spanClasses.sm[columns.sm]);
+  }
+  if (columns.md) {
+    classes.push(spanClasses.md[columns.md]);
+  }
+  if (columns.lg) {
+    classes.push(spanClasses.lg[columns.lg]);
+  }
+  if (columns.xl) {
+    classes.push(spanClasses.xl[columns.xl]);
+  }
+  return classes;
+}

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: Record<string, unknown>, 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,74 @@
+export function parsePath(path) {
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+}
+export function getPath(object, path) {
+  const keys = parsePath(path);
+  let current = object;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+export function setPath(object, path, value) {
+  const keys = parsePath(path);
+  if (keys.length === 0) {
+    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/types.d.mts

@@ -0,0 +1,5 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'
+
+export * from '../dist/runtime/app/types/index.js'

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@groupteknology/vuno",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@iconify-json/lucide": "^1.2.123",
+    "@nuxt/kit": "^4.5.2"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^1.0.3",
+    "@tanstack/vue-query": "^5.0.0",
+    "@types/node": "^22.20.2",
+    "nuxt": "^4.5.2",
+    "typescript": "^6.0.3",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.42",
+    "vue-tsc": "^3.3.11",
+    "zod": "^4.6.2"
+  },
+  "description": "Formularios, tablas y diálogos declarativos para Nuxt 4, construidos sobre Nuxt UI y sin estilos propios.",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "nuxt-ui",
+    "vue",
+    "form",
+    "table",
+    "crud",
+    "datatable",
+    "typescript"
+  ],
+  "license": "MIT",
+  "author": "Diego Otayza <diegootayza@live.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/groupteknology/vuno.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/groupteknology/vuno/issues"
+  },
+  "homepage": "https://github.com/groupteknology/vuno#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@nuxt/ui": "^4.0.0",
+    "@tanstack/vue-query": "^5.0.0",
+    "nuxt": "^4.0.0",
+    "vue": "^3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/vue-query": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "clean": "rm -rf dist",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "typecheck": "nuxt-module-build build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}