@groupteknology/vuno 2.0.0 → 4.0.0

package/dist/runtime/app/components/internal/NumberInput/NumberInput.theme.d.ts

@@ -1,31 +0,0 @@
-export declare const numberInputTheme: Record<"numberInput", {
-    /**
-     * El campo numérico. La caja la pone `baseControl`; aquí solo el control de
-     * dentro y cómo se colocan sus dos botones.
-     *
-     * Los dos botones permanecen juntos al final. En vertical se apilan; en
-     * horizontal quedan lado a lado con el tamaño normal del control. La caja
-     * compartida elimina el relleno final en ambos casos.
-     */
-    readonly slots: {
-        readonly base: "w-full min-w-0 bg-transparent text-right tabular-nums outline-none placeholder:text-vuno-subtle disabled:cursor-not-allowed";
-    };
-    readonly variants: {
-        readonly orientation: {
-            readonly horizontal: {
-                readonly actions: "flex items-center";
-            };
-            /**
-             * Apilados tienen que caber dos dentro de la altura de la caja,
-             * así que el botón pierde su altura propia. Con la del tamaño
-             * `xs` —24 px cada uno— el campo crecía a 49 px de alto en vez
-             * de los 32 que mide un control normal.
-             */
-            readonly vertical: {
-                readonly actions: "flex flex-col-reverse";
-                readonly stepper: "h-3.5 w-7 p-0";
-                readonly stepperIcon: "size-3";
-            };
-        };
-    };
-}>;

package/dist/runtime/app/components/internal/NumberInput/NumberInput.theme.js

@@ -1,26 +0,0 @@
-import { defineTheme } from "#vuno/utils/theme";
-export const numberInputTheme = defineTheme("numberInput", {
-  /**
-   * El campo numérico. La caja la pone `baseControl`; aquí solo el control de
-   * dentro y cómo se colocan sus dos botones.
-   *
-   * Los dos botones permanecen juntos al final. En vertical se apilan; en
-   * horizontal quedan lado a lado con el tamaño normal del control. La caja
-   * compartida elimina el relleno final en ambos casos.
-   */
-  slots: {
-    base: "w-full min-w-0 bg-transparent text-right tabular-nums outline-none placeholder:text-vuno-subtle disabled:cursor-not-allowed"
-  },
-  variants: {
-    orientation: {
-      horizontal: { actions: "flex items-center" },
-      /**
-       * Apilados tienen que caber dos dentro de la altura de la caja,
-       * así que el botón pierde su altura propia. Con la del tamaño
-       * `xs` —24 px cada uno— el campo crecía a 49 px de alto en vez
-       * de los 32 que mide un control normal.
-       */
-      vertical: { actions: "flex flex-col-reverse", stepper: "h-3.5 w-7 p-0", stepperIcon: "size-3" }
-    }
-  }
-});

package/dist/runtime/app/components/internal/NumberInput/NumberInput.vue

@@ -1,221 +0,0 @@
-<script setup>
-import { computed, nextTick, ref } from "vue";
-import { useIcons, useLocale, useMessages, useTheme } from "#vuno/composables/useTheme";
-import Button from "#vuno/components/Button/Button.vue";
-import ControlShell from "#vuno/components/internal/ControlShell/ControlShell.vue";
-import { addStep, clampNumber, isPotentialNumber, parseNumber, snapToStep } from "#vuno/components/internal/NumberInput/number";
-defineOptions({ name: "VunoNumberInput", inheritAttrs: false });
-const model = defineModel({ type: null, ...{ default: void 0 } });
-const props = defineProps({
-  currency: { type: String, required: false, default: void 0 },
-  decimals: { type: Number, required: false, default: void 0 },
-  disabled: { type: Boolean, required: false },
-  max: { type: Number, required: false, default: void 0 },
-  min: { type: Number, required: false, default: void 0 },
-  orientation: { type: String, required: false, default: "horizontal" },
-  size: { type: String, required: false, default: "md" },
-  step: { type: Number, required: false, default: void 0 },
-  ui: { type: Object, required: false, default: void 0 }
-});
-const icons = useIcons();
-const locale = useLocale();
-const messages = useMessages();
-const ui = useTheme(
-  "numberInput",
-  () => props.ui,
-  () => ({ orientation: props.orientation, size: props.size })
-);
-const pointerFocus = ref(false);
-const typing = ref();
-const isVertical = computed(() => props.orientation === "vertical");
-const buttonSize = computed(() => isVertical.value ? "xs" : props.size);
-const stepperUi = computed(() => ({ base: ui.value.stepper, icon: ui.value.stepperIcon }));
-const decimals = computed(() => {
-  if (props.decimals === void 0 || !Number.isFinite(props.decimals)) return void 0;
-  return Math.min(20, Math.max(0, Math.trunc(props.decimals)));
-});
-const digits = computed(() => decimals.value === void 0 ? {} : { maximumFractionDigits: decimals.value, minimumFractionDigits: decimals.value });
-const formatter = computed(() => {
-  return new Intl.NumberFormat(locale.value, props.currency ? { ...digits.value, currency: props.currency, style: "currency" } : digits.value);
-});
-const editingFormatter = computed(() => {
-  const resolved = formatter.value.resolvedOptions();
-  return new Intl.NumberFormat(locale.value, {
-    maximumFractionDigits: resolved.maximumFractionDigits,
-    minimumFractionDigits: 0,
-    useGrouping: false
-  });
-});
-const step = computed(() => props.step ?? (props.currency ? 10 ** -(formatter.value.resolvedOptions().maximumFractionDigits ?? 0) : 1));
-const display = computed(() => {
-  if (typing.value !== void 0) return typing.value;
-  return model.value === void 0 ? "" : formatter.value.format(model.value);
-});
-const atMin = computed(() => props.min !== void 0 && model.value !== void 0 && model.value <= props.min);
-const atMax = computed(() => props.max !== void 0 && model.value !== void 0 && model.value >= props.max);
-function formatEditing(value) {
-  return editingFormatter.value.formatToParts(value).filter((part) => part.type !== "group" && part.type !== "literal").map((part) => part.value).join("");
-}
-function commit(value) {
-  if (value === void 0) {
-    model.value = void 0;
-    return void 0;
-  }
-  const committed = clampNumber(snapToStep(value, step.value, props.min), props.min, props.max);
-  model.value = committed;
-  return committed;
-}
-function nudge(direction, multiplier = 1) {
-  if (props.disabled) return void 0;
-  const draft = typing.value === void 0 ? void 0 : parseNumber(typing.value, locale.value);
-  const from = draft ?? model.value ?? props.min ?? 0;
-  return commit(draft === void 0 && model.value === void 0 ? from : addStep(from, direction * step.value * multiplier));
-}
-function onKeydown(event) {
-  if (props.disabled) return;
-  const actions = {
-    End: props.max === void 0 ? void 0 : () => commit(props.max),
-    Home: props.min === void 0 ? void 0 : () => commit(props.min),
-    ArrowDown: () => nudge(-1),
-    ArrowUp: () => nudge(1),
-    PageDown: () => nudge(-1, 10),
-    PageUp: () => nudge(1, 10)
-  };
-  const action = actions[event.key];
-  if (!action) return;
-  event.preventDefault();
-  const value = action();
-  typing.value = value === void 0 ? "" : formatEditing(value);
-}
-function onWheel(event) {
-  if (props.disabled || event.target !== document.activeElement) return;
-  if (Math.abs(event.deltaY) <= Math.abs(event.deltaX)) return;
-  event.preventDefault();
-  const value = nudge(event.deltaY < 0 ? 1 : -1);
-  typing.value = value === void 0 ? "" : formatEditing(value);
-}
-function onInput(event) {
-  const input = event.target;
-  if (isPotentialNumber(input.value, locale.value)) {
-    typing.value = input.value;
-    return;
-  }
-  input.value = typing.value ?? display.value;
-}
-async function beginEditing(input, selectAll) {
-  const formatted = input.value;
-  const formattedCaret = input.selectionStart ?? formatted.length;
-  const editing = model.value === void 0 ? "" : formatEditing(model.value);
-  const editingCharacters = new Set(editing);
-  let charactersBeforeCaret = 0;
-  for (const character of formatted.slice(0, formattedCaret)) {
-    if (editingCharacters.has(character)) charactersBeforeCaret++;
-  }
-  typing.value = editing;
-  await nextTick();
-  if (selectAll) {
-    input.select();
-    return;
-  }
-  let editingCaret = 0;
-  for (const character of [...editing].slice(0, charactersBeforeCaret)) editingCaret += character.length;
-  input.setSelectionRange(editingCaret, editingCaret);
-}
-async function onClick(event) {
-  const input = event.currentTarget;
-  if (typing.value === void 0) await beginEditing(input, false);
-  pointerFocus.value = false;
-}
-function onFocus(event) {
-  if (props.disabled) return;
-  if (pointerFocus.value) return;
-  void beginEditing(event.currentTarget, true);
-}
-function onPointerdown() {
-  pointerFocus.value = true;
-}
-function onPointercancel() {
-  pointerFocus.value = false;
-}
-function onBlur() {
-  pointerFocus.value = false;
-  if (typing.value === void 0) return;
-  const parsed = parseNumber(typing.value, locale.value);
-  if (!typing.value.trim()) commit(void 0);
-  else if (parsed !== void 0) commit(parsed);
-  typing.value = void 0;
-}
-</script>
-
-<template>
-    <ControlShell
-        :size="props.size"
-        :ui="props.ui"
-    >
-        <!--
-            `type="text"` y no `number`: el nativo acepta texto que no es un
-            número, se anuncia como caja de texto y cambia con la rueda sin
-            tener el foco. El papel de `spinbutton` con sus tres `aria-value*`
-            es lo que lo convierte en un control de número para quien no ve la
-            pantalla.
-        -->
-        <input
-            v-bind="$attrs"
-            :aria-valuemax="props.max"
-            :aria-valuemin="props.min"
-            :aria-valuenow="model"
-            :aria-valuetext="props.currency && model !== void 0 ? formatter.format(model) : void 0"
-            autocomplete="off"
-            autocorrect="off"
-            :class="ui.base"
-            :disabled="props.disabled"
-            inputmode="decimal"
-            role="spinbutton"
-            spellcheck="false"
-            type="text"
-            :value="display"
-            @blur="onBlur"
-            @click="onClick"
-            @focus="onFocus"
-            @input="onInput"
-            @keydown="onKeydown"
-            @pointercancel="onPointercancel"
-            @pointerdown="onPointerdown"
-            @wheel="onWheel"
-        />
-
-        <template #trailing>
-            <!--
-                Los botones quedan fuera del tabulador a propósito: el control ya
-                sube y baja con las flechas, y dos paradas más por campo numérico
-                alargan el recorrido del teclado sin añadir nada que no se
-                pudiera hacer.
-            -->
-            <div :class="ui.actions">
-                <Button
-                    :aria-label="messages.numberDecrement"
-                    color="neutral"
-                    :disabled="props.disabled || atMin"
-                    :icon="icons.numberDecrement"
-                    :size="buttonSize"
-                    tabindex="-1"
-                    :ui="stepperUi"
-                    variant="ghost"
-                    @click="nudge(-1)"
-                />
-
-                <Button
-                    :aria-label="messages.numberIncrement"
-                    color="neutral"
-                    :disabled="props.disabled || atMax"
-                    :icon="icons.numberIncrement"
-                    :size="buttonSize"
-                    tabindex="-1"
-                    :ui="stepperUi"
-                    variant="ghost"
-                    @click="nudge(1)"
-                />
-            </div>
-        </template>
-    </ControlShell>
-</template>

package/dist/runtime/app/components/internal/NumberInput/NumberInput.vue.d.ts

@@ -1,36 +0,0 @@
-import type { VunoSize } from '#vuno/types/base';
-import type { VunoControlOrientation } from '#vuno/types/field';
-import type { VunoUi } from '#vuno/types/slots';
-type __VLS_Props = Props;
-type Props = {
-    currency?: string;
-    decimals?: number;
-    disabled?: boolean;
-    max?: number;
-    min?: number;
-    /** En vertical los botones se apilan; en horizontal, quedan lado a lado. */
-    orientation?: VunoControlOrientation;
-    size?: VunoSize;
-    step?: number;
-    ui?: VunoUi<'control' | 'input' | 'numberInput'>;
-};
-type __VLS_ModelProps = {
-    modelValue?: number | undefined;
-};
-type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
-declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: number | undefined) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: number | undefined) => any) | undefined;
-}>, {
-    currency: string;
-    size: VunoSize;
-    orientation: VunoControlOrientation;
-    ui: VunoUi<"control" | "input" | "numberInput">;
-    decimals: number;
-    max: number;
-    min: number;
-    step: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

@@ -1,19 +0,0 @@
-import type { MaybeRefOrGetter } from 'vue';
-import type { VunoShortcuts, VunoShortcutsOptions } from '#vuno/types/shortcuts';
-/**
- * Atajos de teclado, declarados donde se usan.
- *
- * Se llama `define…` y no `use…` aunque viva en `composables/`, y es
- * deliberado: no devuelve estado sino una forma de parar, y lo que hace es
- * **declarar** algo que se recoge solo al desmontar. `useShortcuts` prometería
- * un valor que nadie lee.
- *
- * Se engancha **una vez** al documento y no un oyente por atajo: con quince
- * atajos declarados en una pantalla, lo segundo instala quince manejadores que
- * corren todos en cada pulsación.
- *
- * @param config El mapa de atajos. Admite un `ref` o un getter para cambiarlos sin volver a montar.
- * @param options Retardo de la secuencia y comparación por posición física.
- * @returns Una función que desengancha, por si hay que parar antes de desmontar.
- */
-export declare function defineShortcuts(config: MaybeRefOrGetter<VunoShortcuts>, options?: VunoShortcutsOptions): () => void;

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

@@ -1,68 +0,0 @@
-import { onScopeDispose, toValue } from "vue";
-export function defineShortcuts(config, options = {}) {
-  if (typeof document === "undefined") return () => {
-  };
-  const { chainDelay = 800, layoutIndependent = false } = options;
-  const platform = navigator.userAgentData?.platform ?? navigator.platform ?? "";
-  const isApple = /ipad|iphone|ipod|mac/i.test(platform);
-  let chain = [];
-  let chainedAt = 0;
-  const stop = () => document.removeEventListener("keydown", onKeydown);
-  document.addEventListener("keydown", onKeydown);
-  onScopeDispose(stop, true);
-  return stop;
-  function onKeydown(event) {
-    const entries = Object.entries(toValue(config)).filter(([, shortcut]) => Boolean(shortcut));
-    const now = Date.now();
-    chain = now - chainedAt > chainDelay ? [describe(event)] : [...chain, describe(event)];
-    chainedAt = now;
-    for (let length = chain.length; length > 0; length--) {
-      const candidate = chain.slice(-length).join("-");
-      const found = entries.find(([name]) => normalize(name) === candidate);
-      if (!found) continue;
-      const shortcut = resolve(found[1]);
-      if (!allowed(shortcut.usingInput, event)) continue;
-      event.preventDefault();
-      chain = [];
-      shortcut.handler(event);
-      return;
-    }
-  }
-  function describe(event) {
-    const parts = [];
-    if (isApple ? event.metaKey : event.ctrlKey) parts.push("meta");
-    if (isApple ? event.ctrlKey : false) parts.push("ctrl");
-    if (event.altKey) parts.push("alt");
-    if (event.shiftKey) parts.push("shift");
-    parts.push(key(event));
-    return parts.join("_");
-  }
-  function key(event) {
-    if (layoutIndependent)
-      return event.code.replace(/^Digit/, "").replace(/^Key/, "").toLowerCase();
-    return event.key === " " ? "space" : event.key.toLowerCase();
-  }
-}
-function normalize(name) {
-  return name.split("-").map((step) => {
-    const parts = step.toLowerCase().split("_");
-    const pressed = parts.at(-1) ?? "";
-    const modifiers = new Set(
-      parts.slice(0, -1).map((modifier) => {
-        if (modifier === "command") return "meta";
-        return modifier === "option" ? "alt" : modifier;
-      })
-    );
-    return [...["meta", "ctrl", "alt", "shift"].filter((modifier) => modifiers.has(modifier)), pressed].join("_");
-  }).join("-");
-}
-function resolve(shortcut) {
-  return typeof shortcut === "function" ? { handler: shortcut } : shortcut;
-}
-function allowed(usingInput, event) {
-  const target = event.target;
-  const editing = Boolean(target?.closest('input, textarea, select, [contenteditable=""], [contenteditable="true"]'));
-  if (!editing || usingInput === true) return true;
-  if (typeof usingInput === "string") return target?.closest("[name]")?.getAttribute("name") === usingInput;
-  return false;
-}

package/dist/runtime/app/composables/internal/useVunoAnchor.d.ts

@@ -1,45 +0,0 @@
-import type { ComputePositionReturn, Middleware } from '@floating-ui/dom';
-import type { MaybeRefOrGetter } from 'vue';
-import type { VunoPlacement } from '#vuno/types/base';
-/**
- * Anclar algo flotante a algo que está en la página, y mantenerlo anclado.
- *
- * Lo usan el menú, el aviso y la lista del combobox. Antes lo escribía cada uno
- * y las tres copias **ya habían divergido**: dos comprobaban que
- * `ResizeObserver` existe antes de pedirle a `autoUpdate` que observe el tamaño
- * y la tercera no, dos volvían a mirar el elemento después del `await` y la
- * tercera lo hacía de otra forma. Hoy eso no cuesta nada —el DOM de las pruebas
- * trae los dos observadores— y por eso vale como aviso y no como avería: es la
- * misma decisión tomada tres veces, y ya iba por caminos distintos.
- *
- * Lo que queda aquí es lo que los tres hacen igual. Lo que los distingue —dónde
- * se coloca, cuánto se separa, qué mide además— entra por parámetro.
- */
-type VunoAnchorOptions = {
-    /**
-     * Se llama con la posición ya resuelta, después de colocar.
-     *
-     * Existe por el `placement` **resuelto**: con `flip`, un aviso pedido arriba
-     * que no cabe acaba abajo, y quien pinte una flecha leyendo el prop la deja
-     * pegada al lado que ya no toca.
-     */
-    onPlaced?: (position: ComputePositionReturn) => void;
-    /** El elemento de la flecha, si lo hay. Su posición llega en `onPlaced`. */
-    arrowElement?: MaybeRefOrGetter<HTMLElement | undefined>;
-    /**
-     * Contra qué se recorta. Para una lista dentro de un `<dialog>` es el
-     * diálogo: sin esto voltea contra la ventana y se sale de la caja que de
-     * verdad la contiene.
-     */
-    boundary?: MaybeRefOrGetter<Element | undefined>;
-    /** Separación entre el ancla y lo flotante, en píxeles. */
-    distance?: MaybeRefOrGetter<number | undefined>;
-    placement?: MaybeRefOrGetter<VunoPlacement>;
-    /** Lo que este control necesite además de la base: medir, recortar, lo que sea. */
-    middleware?: () => Middleware[];
-};
-export declare function useVunoAnchor(options?: VunoAnchorOptions): {
-    anchor: (reference: HTMLElement | undefined, floating: HTMLElement | undefined) => void;
-    release: () => void;
-};
-export {};

package/dist/runtime/app/composables/internal/useVunoAnchor.js

@@ -1,35 +0,0 @@
-import { arrow, autoUpdate, computePosition, flip, offset, shift } from "@floating-ui/dom";
-import { onScopeDispose, toValue } from "vue";
-export function useVunoAnchor(options = {}) {
-  let stop;
-  async function place(reference, floating) {
-    const edge = toValue(options.boundary);
-    const overflow = { padding: 8, ...edge ? { boundary: edge } : {} };
-    const middleware = [offset(toValue(options.distance) ?? 4), flip(overflow), shift(overflow)];
-    const arrowElement = toValue(options.arrowElement);
-    if (arrowElement) middleware.push(arrow({ element: arrowElement }));
-    middleware.push(...options.middleware?.() ?? []);
-    const position = await computePosition(reference, floating, {
-      middleware,
-      placement: toValue(options.placement) ?? "bottom-start",
-      strategy: "fixed"
-    });
-    if (!floating.isConnected) return;
-    Object.assign(floating.style, { left: `${position.x}px`, top: `${position.y}px` });
-    options.onPlaced?.(position);
-  }
-  function anchor(reference, floating) {
-    release();
-    if (!reference || !floating) return;
-    stop = autoUpdate(reference, floating, () => void place(reference, floating), {
-      elementResize: typeof ResizeObserver !== "undefined",
-      layoutShift: typeof IntersectionObserver !== "undefined"
-    });
-  }
-  function release() {
-    stop?.();
-    stop = void 0;
-  }
-  onScopeDispose(release, true);
-  return { anchor, release };
-}

package/dist/runtime/app/composables/internal/useVunoControlGroup.d.ts

@@ -1,17 +0,0 @@
-import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
-import type { VunoSize } from '#vuno/types/base';
-import type { VunoControlOrientation } from '#vuno/types/field';
-type VunoControlGroupContext = {
-    orientation?: VunoControlOrientation;
-    size?: VunoSize;
-};
-/** Provee el contexto sin exponer la clave de inyección a sus consumidores. */
-export declare function provideVunoControlGroup(context: MaybeRefOrGetter<VunoControlGroupContext>): void;
-/** Contexto visual del grupo más cercano; no añade semántica al control. */
-export declare function useVunoControlGroup(): {
-    orientation: ComputedRef<VunoControlOrientation | undefined>;
-    size: ComputedRef<VunoSize | undefined>;
-};
-/** Impide que las acciones internas de un control se comporten como hijos del grupo exterior. */
-export declare function resetControlGroup(): void;
-export {};

package/dist/runtime/app/composables/internal/useVunoControlGroup.js

@@ -1,18 +0,0 @@
-import { computed, inject, provide, toValue } from "vue";
-const vunoControlGroupInjectionKey = Symbol("vuno.control-group");
-export function provideVunoControlGroup(context) {
-  provide(
-    vunoControlGroupInjectionKey,
-    computed(() => toValue(context))
-  );
-}
-export function useVunoControlGroup() {
-  const group = inject(vunoControlGroupInjectionKey, void 0);
-  return {
-    orientation: computed(() => group?.value.orientation),
-    size: computed(() => group?.value.size)
-  };
-}
-export function resetControlGroup() {
-  provideVunoControlGroup({});
-}

package/dist/runtime/app/composables/internal/useVunoPortal.d.ts

@@ -1,18 +0,0 @@
-import type { ComputedRef, MaybeRefOrGetter } from 'vue';
-import type { VunoPortalTarget } from '#vuno/types/base';
-/**
- * Dónde montar un desplegable para que se vea.
- *
- * Un `<dialog>` abierto con `showModal()` vive en la **capa superior** del
- * navegador, que está por encima de cualquier `z-index`. Un desplegable que se
- * monte en `body` —lo que hacen por defecto los componentes de Nuxt UI— queda
- * por debajo de esa capa: se abre de verdad, con su `aria-expanded` y su
- * `listbox` en el DOM, colocado en el sitio correcto, y no se ve. El campo
- * parece roto sin que nada falle.
- *
- * La salida es montarlo **dentro** del propio diálogo, que ya está en la capa
- * superior. Fuera de un modal no hay nada que proveer y se usa `body`.
- */
-export declare function useVunoPortal(target?: MaybeRefOrGetter<undefined | VunoPortalTarget>): ComputedRef<string>;
-/** Lo llama quien abre una capa superior, para que sus campos la encuentren. */
-export declare function provideVunoPortal(target: VunoPortalTarget): void;

package/dist/runtime/app/composables/internal/useVunoPortal.js

@@ -1,12 +0,0 @@
-import { computed, inject, provide, toValue } from "vue";
-const vunoPortalInjectionKey = Symbol("vuno-portal");
-export function useVunoPortal(target) {
-  const injected = inject(vunoPortalInjectionKey, true);
-  return computed(() => {
-    const resolved = toValue(target) ?? injected;
-    return resolved === true ? "body" : resolved;
-  });
-}
-export function provideVunoPortal(target) {
-  provide(vunoPortalInjectionKey, target);
-}

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

@@ -1,15 +0,0 @@
-import type { VunoConfirmRequest } from '#vuno/types/app';
-/**
- * Pide confirmación desde el código y espera la respuesta.
- *
- * ```ts
- * if (await confirm({ title: `¿Eliminar ${row.sku}?` })) await borrar(row)
- * ```
- *
- * El componente `VConfirm` sigue estando para quien quiera colocarlo y
- * controlarlo. Esto existe porque lo otro obliga a llevar un `ref` de apertura y
- * otro de la fila pendiente por cada acción confirmable, y eso se abandona: los
- * dos primeros proyectos que usaron el módulo se quedaron con su diálogo propio,
- * y los dos tenían una función como esta.
- */
-export declare function useConfirm(): (request: VunoConfirmRequest) => Promise<boolean>;

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

@@ -1,5 +0,0 @@
-import { useContext } from "./useContext.js";
-export function useConfirm() {
-  const context = useContext();
-  return context.confirm;
-}

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

@@ -1,11 +0,0 @@
-import type { VunoContext } from '#vuno/types/app';
-export type { VunoContext } from '#vuno/types/app';
-/**
- * El contexto global del módulo, provisto por `<VApp>`.
- *
- * Lanza en vez de degradar a un valor vacío: lo que hay aquí —los overlays—
- * necesita un sitio del árbol donde pintarse, y sin `<VApp>` una llamada a
- * `confirm()` devolvería una promesa que no resuelve nunca. Es mejor un error
- * en la primera ejecución que un diálogo que no aparece.
- */
-export declare function useContext(): VunoContext;

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

@@ -1,9 +0,0 @@
-import { inject } from "vue";
-import { vunoContextInjectionKey } from "#vuno/internal/keys";
-export function useContext() {
-  const context = inject(vunoContextInjectionKey, null);
-  if (!context) {
-    throw new Error("[Vuno] useContext() debe utilizarse dentro de <VApp>.");
-  }
-  return context;
-}

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

@@ -1,23 +0,0 @@
-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 = useCrud({
- *   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 useCrud<TRow extends VunoTableRow, TForm extends Record<string, unknown>>(options: VunoCrudOptions<TRow, TForm>): VunoCrud<TRow, TForm>;