@groupteknology/vuno 3.0.0 → 4.0.0

package/dist/runtime/app/components/Tile/Tile.theme.d.ts

@@ -0,0 +1,106 @@
+export declare const tileTheme: Record<"tile", {
+    readonly compoundVariants: [{
+        readonly class: {
+            readonly root: "cursor-pointer hover:bg-(--vuno-layer-hover-01)";
+        };
+        readonly disabled: "false";
+        readonly interactive: "true";
+    }, {
+        readonly class: {
+            readonly chevron: "cursor-pointer hover:bg-(--vuno-layer-hover-01) focus:outline-solid focus:outline-2 focus:-outline-offset-2 focus:outline-(--vuno-focus)";
+        };
+        readonly disabled: "false";
+        readonly interactive: "false";
+        readonly variant: "expandable";
+    }, {
+        readonly class: {
+            readonly chevron: "cursor-not-allowed";
+            readonly root: "cursor-default";
+        };
+        readonly disabled: "true";
+        readonly interactive: "false";
+        readonly variant: "expandable";
+    }, {
+        readonly class: {
+            readonly checkmarkIcon: "text-(--vuno-icon-disabled)";
+            readonly root: "border-(--vuno-border-disabled)";
+        };
+        readonly disabled: "true";
+        readonly selected: "true";
+    }];
+    readonly slots: {
+        /** `vuno--tile-content__above-the-fold`: marca el pliegue, no lo maqueta. */
+        readonly above: "block";
+        /** `vuno--tile-content__below-the-fold`. La separación entre pliegues la decide el contenido. */
+        readonly below: "block";
+        readonly checkmark: "absolute end-4 top-4 flex h-4 items-center text-(--vuno-icon-secondary) transition-colors duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none";
+        readonly checkmarkIcon: "size-4";
+        readonly chevron: "absolute end-0 bottom-0 flex h-12 min-w-12 items-center justify-end gap-2 px-4 text-(--vuno-icon-primary)";
+        readonly chevronIcon: "size-4 shrink-0 transition-transform duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none";
+        readonly chevronLabel: "text-sm/[1.125rem] tracking-[0.16px] whitespace-nowrap text-(--vuno-text-primary)";
+        /** El `fieldset` de `TileGroup`: solo el reinicio que el sistema de origen le da. */
+        readonly group: "m-0 border-0 p-0";
+        readonly icon: "absolute end-3 bottom-3 size-5 text-(--vuno-icon-interactive)";
+        readonly input: "sr-only";
+        /** `label-01` —12/16 con 0.32 px— y el apagado por herencia del `fieldset`. */
+        readonly legend: "mb-2 text-xs/[1rem] tracking-[0.32px] text-(--vuno-text-secondary) in-[:disabled]:text-(--vuno-text-disabled)";
+        /**
+         * La caja que coloca las tiles del grupo. Una sola columna, que es como
+         * las apila el sistema de origen, y el punto por el que quien compone
+         * pide columnas o separación sin tocar la tile.
+         */
+        readonly options: "grid";
+        readonly panel: "block w-full overflow-hidden opacity-0 transition-all transition-discrete duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none";
+        readonly root: "relative m-0 block min-h-16 min-w-32 border-transparent bg-(--vuno-layer-01) p-4 text-start text-sm/[1.125rem] font-normal tracking-[0.16px] text-(--vuno-text-primary) no-underline outline-solid outline-2 -outline-offset-2 outline-transparent focus:outline-(--vuno-focus)";
+    };
+    readonly variants: {
+        readonly disabled: {
+            readonly false: {};
+            readonly true: {
+                readonly checkmarkIcon: "text-(--vuno-icon-disabled)";
+                readonly chevronIcon: "text-(--vuno-icon-disabled)";
+                readonly chevronLabel: "text-(--vuno-text-disabled)";
+                readonly icon: "hidden";
+                readonly root: "cursor-not-allowed text-(--vuno-text-disabled)";
+            };
+        };
+        readonly expanded: {
+            readonly false: {
+                readonly panel: "hidden max-h-0";
+            };
+            readonly true: {
+                readonly chevronIcon: "rotate-180";
+                readonly panel: "max-h-fit overflow-visible opacity-100 starting:max-h-0 starting:opacity-0";
+            };
+        };
+        /**
+         * La superficie es el control. `ExpandableTile` la pone en `false`
+         * cuando el chevron asume ese papel, y `Tile` no declara la dimensión
+         * porque una tile base no es operable.
+         */
+        readonly interactive: {
+            readonly false: {};
+            readonly true: {
+                readonly root: "transition-colors duration-(--vuno-duration-moderate-01) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none";
+            };
+        };
+        readonly selected: {
+            readonly false: {};
+            readonly true: {
+                readonly checkmarkIcon: "text-(--vuno-icon-primary)";
+                readonly root: "border border-(--vuno-layer-selected-inverse)";
+            };
+        };
+        readonly variant: {
+            readonly clickable: {
+                readonly root: "hover:no-underline";
+            };
+            readonly expandable: {
+                readonly root: "w-full";
+            };
+            readonly selectable: {
+                readonly root: "border pe-12 has-[input:focus]:outline-(--vuno-focus)";
+            };
+        };
+    };
+}>;

package/dist/runtime/app/components/Tile/Tile.theme.js

@@ -0,0 +1,115 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const tileTheme = defineTheme("tile", {
+  compoundVariants: [
+    /* La superficie solo reacciona al puntero mientras es operable. */
+    {
+      class: { root: "cursor-pointer hover:bg-(--vuno-layer-hover-01)" },
+      disabled: "false",
+      interactive: "true"
+    },
+    /*
+     * Cuando el contenido de la tile expandible es interactivo, el control
+     * es el chevron y no la superficie: Vuno le devuelve al botón el
+     * `hover` y el contorno de foco, y se los quita al contenedor.
+     */
+    {
+      class: { chevron: "cursor-pointer hover:bg-(--vuno-layer-hover-01) focus:outline-solid focus:outline-2 focus:-outline-offset-2 focus:outline-(--vuno-focus)" },
+      disabled: "false",
+      interactive: "false",
+      variant: "expandable"
+    },
+    /*
+     * Y el bloqueo va al mismo sitio que el control. La superficie conserva
+     * el cursor por defecto —`cursor: default` en el sistema de origen—
+     * porque ahí siguen vivos los enlaces y botones del pliegue superior:
+     * marcarla entera de prohibida mentiría sobre qué está bloqueado.
+     */
+    {
+      class: { chevron: "cursor-not-allowed", root: "cursor-default" },
+      disabled: "true",
+      interactive: "false",
+      variant: "expandable"
+    },
+    /*
+     * Una tile seleccionada y deshabilitada conserva el borde, pero en gris:
+     * Vuno solo le cambia el color para que la selección siga siendo
+     * legible sin anunciarse como operable.
+     */
+    {
+      class: { checkmarkIcon: "text-(--vuno-icon-disabled)", root: "border-(--vuno-border-disabled)" },
+      disabled: "true",
+      selected: "true"
+    }
+  ],
+  slots: {
+    /** `vuno--tile-content__above-the-fold`: marca el pliegue, no lo maqueta. */
+    above: "block",
+    /** `vuno--tile-content__below-the-fold`. La separación entre pliegues la decide el contenido. */
+    below: "block",
+    checkmark: "absolute end-4 top-4 flex h-4 items-center text-(--vuno-icon-secondary) transition-colors duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none",
+    checkmarkIcon: "size-4",
+    chevron: "absolute end-0 bottom-0 flex h-12 min-w-12 items-center justify-end gap-2 px-4 text-(--vuno-icon-primary)",
+    chevronIcon: "size-4 shrink-0 transition-transform duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none",
+    chevronLabel: "text-sm/[1.125rem] tracking-[0.16px] whitespace-nowrap text-(--vuno-text-primary)",
+    /** El `fieldset` de `TileGroup`: solo el reinicio que el sistema de origen le da. */
+    group: "m-0 border-0 p-0",
+    icon: "absolute end-3 bottom-3 size-5 text-(--vuno-icon-interactive)",
+    input: "sr-only",
+    /** `label-01` —12/16 con 0.32 px— y el apagado por herencia del `fieldset`. */
+    legend: "mb-2 text-xs/[1rem] tracking-[0.32px] text-(--vuno-text-secondary) in-[:disabled]:text-(--vuno-text-disabled)",
+    /**
+     * La caja que coloca las tiles del grupo. Una sola columna, que es como
+     * las apila el sistema de origen, y el punto por el que quien compone
+     * pide columnas o separación sin tocar la tile.
+     */
+    options: "grid",
+    panel: "block w-full overflow-hidden opacity-0 transition-all transition-discrete duration-(--vuno-duration-fast-02) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none",
+    root: "relative m-0 block min-h-16 min-w-32 border-transparent bg-(--vuno-layer-01) p-4 text-start text-sm/[1.125rem] font-normal tracking-[0.16px] text-(--vuno-text-primary) no-underline outline-solid outline-2 -outline-offset-2 outline-transparent focus:outline-(--vuno-focus)"
+  },
+  variants: {
+    disabled: {
+      false: {},
+      /*
+       * `cursor-not-allowed` y no `pointer-events-none`: el cursor de
+       * Vuno solo se ve si el elemento sigue recibiendo el puntero.
+       *
+       * El icono de navegación desaparece en vez de teñirse de gris. Es
+       * lo que hace Vuno hoy —`.vuno--tile--icon { display: none }` bajo
+       * `.vuno--link--disabled`—: la flecha anuncia un destino, y un
+       * destino que no se puede seguir no debe anunciarse. El icono gris
+       * de la pestaña Style pertenece al indicativo de error que solo
+       * aparece con la bandera `enable-v12-tile-default-icons`.
+       */
+      true: { checkmarkIcon: "text-(--vuno-icon-disabled)", chevronIcon: "text-(--vuno-icon-disabled)", chevronLabel: "text-(--vuno-text-disabled)", icon: "hidden", root: "cursor-not-allowed text-(--vuno-text-disabled)" }
+    },
+    expanded: {
+      false: { panel: "hidden max-h-0" },
+      true: { chevronIcon: "rotate-180", panel: "max-h-fit overflow-visible opacity-100 starting:max-h-0 starting:opacity-0" }
+    },
+    /**
+     * La superficie es el control. `ExpandableTile` la pone en `false`
+     * cuando el chevron asume ese papel, y `Tile` no declara la dimensión
+     * porque una tile base no es operable.
+     */
+    interactive: {
+      false: {},
+      true: { root: "transition-colors duration-(--vuno-duration-moderate-01) ease-(--vuno-easing-standard-productive) motion-reduce:transition-none" }
+    },
+    selected: {
+      false: {},
+      true: { checkmarkIcon: "text-(--vuno-icon-primary)", root: "border border-(--vuno-layer-selected-inverse)" }
+    },
+    variant: {
+      clickable: { root: "hover:no-underline" },
+      /* `inline-size: 100%`, con el chevron de 48 px flotando en la esquina. */
+      expandable: { root: "w-full" },
+      /*
+       * El relleno final reserva la columna de 48 px de la marca, y el
+       * foco se dibuja sobre la superficie porque la casilla que lo
+       * recibe está oculta: es el `.vuno--tile-input:focus + .vuno--tile`
+       * de Vuno.
+       */
+      selectable: { root: "border pe-12 has-[input:focus]:outline-(--vuno-focus)" }
+    }
+  }
+});

package/dist/runtime/app/components/Tile/Tile.types.d.ts

@@ -0,0 +1,16 @@
+import type { Component } from 'vue';
+import type { ComponentUi } from '#vuno/types/slots';
+export type TileProps = {
+    /**
+     * Raíz alternativa. Vuno siempre emite un `div`, pero una tile base suele
+     * ser el contenedor de una región con nombre —`section`, `article`, `li`—
+     * y forzar un `div` obligaría a envolverla solo para recuperar la
+     * semántica.
+     *
+     * La tile base no es operable: si la raíz pasa a ser un control, el
+     * componente que corresponde es `ClickableTile`, `SelectableTile` o
+     * `ExpandableTile`, que además traen su contrato de teclado.
+     */
+    tag?: Component | string;
+    ui?: ComponentUi<'tile'>;
+};

package/dist/runtime/app/components/Tile/Tile.vue

@@ -0,0 +1,19 @@
+<script setup>
+import { useTheme } from "#vuno/composables/useTheme";
+defineOptions({ name: "Tile" });
+const props = defineProps({
+  tag: { type: null, required: false, default: "div" },
+  ui: { type: Object, required: false, default: void 0 }
+});
+defineSlots();
+const ui = useTheme("tile", () => props.ui);
+</script>
+
+<template>
+    <component
+        :is="props.tag"
+        :class="ui.root"
+    >
+        <slot />
+    </component>
+</template>

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

@@ -0,0 +1,16 @@
+import type { TileProps } from './Tile.types.js';
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<TileProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TileProps> & Readonly<{}>, {
+    tag: import("vue").Component | string;
+    ui: import("../../types/slots.js").ComponentUi<"tile">;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,12 @@
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/TileAboveTheFoldContent/TileAboveTheFoldContent.vue

@@ -0,0 +1,12 @@
+<script setup>
+import { useTheme } from "#vuno/composables/useTheme";
+defineOptions({ name: "TileAboveTheFoldContent" });
+defineSlots();
+const ui = useTheme("tile");
+</script>
+
+<template>
+    <div :class="ui.above">
+        <slot />
+    </div>
+</template>

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

@@ -0,0 +1,12 @@
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,12 @@
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/TileBelowTheFoldContent/TileBelowTheFoldContent.vue

@@ -0,0 +1,12 @@
+<script setup>
+import { useTheme } from "#vuno/composables/useTheme";
+defineOptions({ name: "TileBelowTheFoldContent" });
+defineSlots();
+const ui = useTheme("tile");
+</script>
+
+<template>
+    <div :class="ui.below">
+        <slot />
+    </div>
+</template>

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

@@ -0,0 +1,12 @@
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,28 @@
+import type { TileGroupProps, TileGroupValue } from './TileGroup.types.js';
+type __VLS_Props = TileGroupProps;
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: TileGroupValue | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("../../types/control.js").OptionValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("../../types/control.js").OptionValue | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    legend: string;
+    name: string;
+    ui: import("../../types/slots.js").ComponentUi<"tile">;
+    required: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/TileGroup/TileGroup.types.d.ts

@@ -0,0 +1,30 @@
+import type { OptionValue } from '#vuno/types/control';
+import type { ComponentUi } from '#vuno/types/slots';
+export type TileGroupProps = {
+    /**
+     * Nombre con el que la elección viaja en el formulario y, sobre todo, lo
+     * que agrupa los radios: sin un nombre común el navegador no los excluye
+     * entre sí ni los recorre con las flechas.
+     *
+     * En el sistema de origen es obligatorio. Aquí es opcional y el grupo
+     * genera uno estable en servidor y cliente, igual que `RadioButtonGroup`:
+     * un grupo que no se envía en un formulario sigue necesitando el nombre
+     * para comportarse como grupo, y obligar a inventárselo no aporta nada.
+     */
+    name?: string;
+    disabled?: boolean;
+    /**
+     * Rótulo del grupo. Sin declararlo no se dibuja la `legend`, como en el
+     * sistema de origen; en ese caso el grupo debe recibir su nombre accesible
+     * por otra vía —`aria-label` o `aria-labelledby`— porque un `fieldset` sin
+     * leyenda se anuncia sin nombre.
+     */
+    legend?: string;
+    required?: boolean;
+    ui?: ComponentUi<'tile'>;
+};
+/**
+ * El valor de la tile elegida. Es el mismo contrato de valor que el resto de
+ * las listas del paquete, no uno propio del grupo.
+ */
+export type TileGroupValue = OptionValue;

package/dist/runtime/app/components/TileGroup/TileGroup.vue

@@ -0,0 +1,47 @@
+<script setup>
+import { computed, provide, useId } from "vue";
+import { useTheme } from "#vuno/composables/useTheme";
+import { tileGroupContextKey } from "./internal/context";
+defineOptions({ name: "TileGroup" });
+const model = defineModel({ type: [Boolean, null, Number, String], skipCheck: true, ...{ default: void 0 } });
+const props = defineProps({
+  name: { type: String, required: false, default: void 0 },
+  disabled: { type: Boolean, required: false, default: false },
+  legend: { type: String, required: false, default: void 0 },
+  required: { type: Boolean, required: false, default: false },
+  ui: { type: Object, required: false, default: void 0 }
+});
+defineSlots();
+const uid = useId();
+const ui = useTheme("tile", () => props.ui);
+provide(tileGroupContextKey, {
+  name: computed(() => props.name ?? uid),
+  disabled: computed(() => props.disabled),
+  required: computed(() => props.required),
+  value: model
+});
+</script>
+
+<template>
+    <fieldset
+        :class="ui.group"
+        :disabled="props.disabled"
+    >
+        <legend
+            v-if="props.legend"
+            :class="ui.legend"
+        >
+            {{ props.legend }}
+        </legend>
+
+        <!--
+            La caja de opciones es la que coloca las tiles, y por eso es un slot de tema: el
+            sistema de origen las apila pegadas y quien compone decide con `ui.options` si van
+            en columnas, con separación o en línea. La geometría de la retícula es del
+            contenedor, no de la tile.
+        -->
+        <div :class="ui.options">
+            <slot />
+        </div>
+    </fieldset>
+</template>

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

@@ -0,0 +1,28 @@
+import type { TileGroupProps, TileGroupValue } from './TileGroup.types.js';
+type __VLS_Props = TileGroupProps;
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: TileGroupValue | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("../../types/control.js").OptionValue | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("../../types/control.js").OptionValue | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    legend: string;
+    name: string;
+    ui: import("../../types/slots.js").ComponentUi<"tile">;
+    required: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/TileGroup/internal/context.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import type { OptionValue } from '#vuno/types/control';
+export type TileGroupContext = {
+    /**
+     * El nombre compartido de las tiles, que es lo que las convierte en un solo
+     * grupo para el navegador. Viaja como `ComputedRef` porque es una prop:
+     * leerlo una vez en el montaje dejaría a las tiles con el nombre anterior
+     * cuando el grupo cambia de `name`, y dos grupos con el mismo nombre se
+     * comportan como uno.
+     */
+    name: ComputedRef<string>;
+    /**
+     * El `fieldset` apagado ya bloquea los radios por herencia del DOM, pero esa
+     * herencia no llega al tema: cada tile necesita saberlo para pintarse
+     * apagada.
+     */
+    disabled: ComputedRef<boolean>;
+    required: ComputedRef<boolean>;
+    value: Ref<OptionValue | undefined>;
+};
+export declare const tileGroupContextKey: InjectionKey<TileGroupContext>;

package/dist/runtime/app/components/TileGroup/internal/context.js

@@ -0,0 +1 @@
+export const tileGroupContextKey = Symbol("tile-group");

package/dist/runtime/app/components/TimePicker/TimePicker.context.d.ts

@@ -0,0 +1,23 @@
+import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import type { ControlSize } from '#vuno/types/control';
+/**
+ * Lo que el campo de la hora reparte a los selectores que lo acompañan.
+ *
+ * En el sistema de origen no hay contexto: el campo clona a sus hijos y les
+ * inyecta `disabled`, `readOnly` y los dos manejadores que impiden desplegar en
+ * solo lectura. Clonar hijos no existe en Vue, y tampoco hace falta: el
+ * selector resuelve su propio tema y su propio teclado, así que lo único que
+ * necesita del contenedor son las tres decisiones que no puede tomar por su
+ * cuenta.
+ *
+ * El tamaño viaja aquí y no como prop del selector a propósito: una fila con el
+ * campo a 48 px y el AM/PM a 40 px no es una variante, es un error, y el
+ * contenedor es el único que sabe cuál es el alto de la fila.
+ */
+export type TimePickerContext = {
+    /** Calculado, porque solo lectura ya lo ha anulado antes de repartirlo. */
+    disabled: ComputedRef<boolean>;
+    readonly: Ref<boolean>;
+    size: Ref<ControlSize>;
+};
+export declare const timePickerKey: InjectionKey<TimePickerContext>;

package/dist/runtime/app/components/TimePicker/TimePicker.context.js

@@ -0,0 +1 @@
+export const timePickerKey = Symbol("time-picker");

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

@@ -0,0 +1,40 @@
+import type { TimePickerProps } from './TimePicker.types.js';
+type __VLS_Props = TimePickerProps;
+type __VLS_Slots = {
+    /** Los `TimePickerSelect` de la fila: el periodo AM/PM y la zona horaria. */
+    default?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: string | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    disabled: boolean;
+    size: import("../../types/control.js").ControlSize;
+    invalid: boolean;
+    warn: boolean;
+    type: import("./TimePicker.types.js").TimePickerType;
+    placeholder: string;
+    name: string;
+    hideLabel: boolean;
+    readonly: boolean;
+    pattern: string;
+    id: string;
+    ui: import("../../types/slots.js").ComponentUi<"timePicker">;
+    required: boolean;
+    invalidText: string;
+    warnText: string;
+    maxlength: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};