@groupteknology/vuno 2.0.0 → 3.0.0

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

@@ -0,0 +1,19 @@
+import type { VunoTextProps } from './Text.types.js';
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<VunoTextProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoTextProps> & Readonly<{}>, {
+    variant: import("../../types/text.js").VunoTextVariant;
+    tag: import("../../types/text.js").VunoTextTag;
+    truncate: number;
+    tone: import("../../types/text.js").VunoTextTone;
+    ui: import("../../types/slots.js").VunoUi<"text">;
+}, {}, {}, {}, 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/Text/Text.theme.d.ts

@@ -0,0 +1,55 @@
+export declare const textTheme: Record<"text", {
+    readonly slots: {
+        readonly root: "";
+    };
+    readonly variants: {
+        readonly tone: {
+            readonly body: {
+                readonly root: "text-vuno-body";
+            };
+            readonly inherit: {};
+            readonly inverse: {
+                readonly root: "text-vuno-inverse";
+            };
+            readonly muted: {
+                readonly root: "text-vuno-muted";
+            };
+            readonly strong: {
+                readonly root: "text-vuno-strong";
+            };
+            readonly subtle: {
+                readonly root: "text-vuno-subtle";
+            };
+        };
+        readonly truncate: {
+            readonly false: {};
+            readonly true: {
+                readonly root: "line-clamp-(--vuno-text-lines)";
+            };
+        };
+        readonly variant: {
+            readonly body: {
+                readonly root: "font-sans text-sm/5 font-normal";
+            };
+            readonly caption: {
+                readonly root: "font-sans text-xs/4 font-normal";
+            };
+            readonly code: {
+                readonly root: "font-mono text-sm/5 font-normal";
+            };
+            readonly display: {
+                readonly root: "font-sans text-3xl/9 font-semibold tracking-[-0.03em]";
+            };
+            readonly heading: {
+                readonly root: "font-sans text-xl/7 font-semibold tracking-[-0.02em]";
+            };
+            readonly inherit: {};
+            readonly label: {
+                readonly root: "font-sans text-xs/4 font-medium";
+            };
+            readonly title: {
+                readonly root: "font-sans text-base/6 font-semibold";
+            };
+        };
+    };
+}>;

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

@@ -0,0 +1,28 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const textTheme = defineTheme("text", {
+  slots: { root: "" },
+  variants: {
+    tone: {
+      body: { root: "text-vuno-body" },
+      inherit: {},
+      inverse: { root: "text-vuno-inverse" },
+      muted: { root: "text-vuno-muted" },
+      strong: { root: "text-vuno-strong" },
+      subtle: { root: "text-vuno-subtle" }
+    },
+    truncate: {
+      false: {},
+      true: { root: "line-clamp-(--vuno-text-lines)" }
+    },
+    variant: {
+      body: { root: "font-sans text-sm/5 font-normal" },
+      caption: { root: "font-sans text-xs/4 font-normal" },
+      code: { root: "font-mono text-sm/5 font-normal" },
+      display: { root: "font-sans text-3xl/9 font-semibold tracking-[-0.03em]" },
+      heading: { root: "font-sans text-xl/7 font-semibold tracking-[-0.02em]" },
+      inherit: {},
+      label: { root: "font-sans text-xs/4 font-medium" },
+      title: { root: "font-sans text-base/6 font-semibold" }
+    }
+  }
+});

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

@@ -0,0 +1,9 @@
+import type { VunoUi } from '#vuno/types/slots';
+import type { VunoTextTag, VunoTextTone, VunoTextVariant } from '#vuno/types/text';
+export type VunoTextProps = {
+    tag?: VunoTextTag;
+    tone?: VunoTextTone;
+    truncate?: number;
+    ui?: VunoUi<'text'>;
+    variant?: VunoTextVariant;
+};

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

@@ -0,0 +1,37 @@
+<script setup>
+import { computed } from "vue";
+import { useTheme } from "#vuno/composables/useTheme";
+defineOptions({ name: "VunoText" });
+const props = defineProps({
+  tag: { type: String, required: false, default: "span" },
+  tone: { type: String, required: false, default: "body" },
+  truncate: { type: Number, required: false, default: void 0 },
+  ui: { type: Object, required: false, default: void 0 },
+  variant: { type: String, required: false, default: "body" }
+});
+defineSlots();
+const clampLines = computed(() => {
+  if (props.truncate === void 0 || !Number.isFinite(props.truncate) || props.truncate < 1) return void 0;
+  return Math.trunc(props.truncate);
+});
+const clampStyle = computed(() => clampLines.value ? { "--vuno-text-lines": String(clampLines.value) } : void 0);
+const ui = useTheme(
+  "text",
+  () => props.ui,
+  () => ({
+    tone: props.tone,
+    truncate: clampLines.value ? "true" : "false",
+    variant: props.variant
+  })
+);
+</script>
+
+<template>
+    <component
+        :is="props.tag"
+        :class="ui.root"
+        :style="clampStyle"
+    >
+        <slot />
+    </component>
+</template>

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

@@ -0,0 +1,19 @@
+import type { VunoTextProps } from './Text.types.js';
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<VunoTextProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoTextProps> & Readonly<{}>, {
+    variant: import("../../types/text.js").VunoTextVariant;
+    tag: import("../../types/text.js").VunoTextTag;
+    truncate: number;
+    tone: import("../../types/text.js").VunoTextTone;
+    ui: import("../../types/slots.js").VunoUi<"text">;
+}, {}, {}, {}, 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/Toolbar/Toolbar.d.vue.ts

@@ -0,0 +1,17 @@
+import type { VunoToolbarProps } from './Toolbar.types.js';
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<VunoToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoToolbarProps> & Readonly<{}>, {
+    size: import("./Toolbar.types.js").VunoToolbarSize;
+    orientation: import("../../types/field.js").VunoControlOrientation;
+    ui: import("../../types/slots.js").VunoUi<"toolbar">;
+}, {}, {}, {}, 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/Toolbar/Toolbar.theme.d.ts

@@ -0,0 +1,5 @@
+export declare const toolbarTheme: Record<"toolbar", {
+    readonly slots: {
+        readonly root: "max-w-full items-stretch";
+    };
+}>;

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

@@ -0,0 +1,6 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const toolbarTheme = defineTheme("toolbar", {
+  slots: {
+    root: "max-w-full items-stretch"
+  }
+});

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

@@ -0,0 +1,9 @@
+import type { VunoSize } from '#vuno/types/base';
+import type { VunoControlOrientation } from '#vuno/types/field';
+import type { VunoUi } from '#vuno/types/slots';
+export type VunoToolbarSize = Extract<VunoSize, 'lg' | 'md' | 'sm' | 'xl' | 'xs'>;
+export type VunoToolbarProps = {
+    orientation?: VunoControlOrientation;
+    size?: VunoToolbarSize;
+    ui?: VunoUi<'toolbar'>;
+};

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

@@ -0,0 +1,76 @@
+<script setup>
+import { useVunoDirection } from "#vuno/composables/internal/useVunoDirection";
+import { useTheme } from "#vuno/composables/useTheme";
+import ControlGroup from "#vuno/components/ControlGroup/ControlGroup.vue";
+defineOptions({ name: "VunoToolbar", inheritAttrs: false });
+const props = defineProps({
+  orientation: { type: String, required: false, default: "horizontal" },
+  size: { type: String, required: false, default: "md" },
+  ui: { type: Object, required: false, default: void 0 }
+});
+defineSlots();
+const ui = useTheme("toolbar", () => props.ui);
+const direction = useVunoDirection();
+const focusableSelector = [
+  "a[href]",
+  "button:not([disabled])",
+  'input:not([disabled]):not([type="hidden"])',
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])'
+].join(",");
+function isAvailable(element) {
+  return element.tabIndex >= 0 && !element.closest('[aria-hidden="true"], [hidden], [inert]');
+}
+function toolbarItems(root) {
+  return Array.from(root.children).flatMap((child) => {
+    if (child instanceof HTMLElement && child.matches(focusableSelector)) return isAvailable(child) ? [child] : [];
+    const control = child.querySelector(focusableSelector);
+    return control && isAvailable(control) ? [control] : [];
+  });
+}
+function isEditable(element) {
+  return element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement && !["button", "checkbox", "color", "file", "radio", "range", "reset", "submit"].includes(element.type);
+}
+function canLeaveEditable(element, step) {
+  const { selectionEnd, selectionStart, value } = element;
+  if (selectionStart === null || selectionEnd === null || selectionStart !== selectionEnd) return false;
+  return step < 0 ? selectionStart === 0 : selectionEnd === value.length;
+}
+function onKeydown(event) {
+  const root = event.currentTarget;
+  const target = event.target;
+  if (!(root instanceof HTMLElement) || !(target instanceof HTMLElement)) return;
+  if (target.closest('[aria-expanded="true"]')) return;
+  const horizontal = props.orientation === "horizontal";
+  const forward = horizontal && direction() === "rtl" ? -1 : 1;
+  const steps = horizontal ? { ArrowLeft: -forward, ArrowRight: forward } : { ArrowDown: 1, ArrowUp: -1 };
+  let step = steps[event.key];
+  if (step === void 0 && event.key !== "Home" && event.key !== "End") return;
+  if (isEditable(target) && (event.key === "Home" || event.key === "End")) return;
+  if (step !== void 0 && isEditable(target) && !canLeaveEditable(target, step)) return;
+  const items = toolbarItems(root);
+  const current = items.findIndex((item) => item === target || item.contains(target));
+  if (current < 0 || items.length === 0) return;
+  if (event.key === "Home") step = -current;
+  if (event.key === "End") step = items.length - 1 - current;
+  const next = items[(current + step + items.length) % items.length];
+  if (!next || next === target) return;
+  event.preventDefault();
+  next.focus();
+}
+</script>
+
+<template>
+    <ControlGroup
+        v-bind="$attrs"
+        :aria-orientation="props.orientation"
+        :orientation="props.orientation"
+        role="toolbar"
+        :size="props.size"
+        :ui="{ root: ui.root }"
+        @keydown="onKeydown"
+    >
+        <slot />
+    </ControlGroup>
+</template>

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

@@ -0,0 +1,17 @@
+import type { VunoToolbarProps } from './Toolbar.types.js';
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<VunoToolbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoToolbarProps> & Readonly<{}>, {
+    size: import("./Toolbar.types.js").VunoToolbarSize;
+    orientation: import("../../types/field.js").VunoControlOrientation;
+    ui: import("../../types/slots.js").VunoUi<"toolbar">;
+}, {}, {}, {}, 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/Tooltip/Tooltip.d.vue.ts

@@ -1,34 +1,13 @@
-import type { VunoPortalTarget } from '#vuno/types/base';
-import type { VunoUi } from '#vuno/types/slots';
-/**
- * El aviso que aparece al posar el ratón o al llegar con el teclado.
- *
- * Las cuatro cosas fáciles de dejarse y difíciles de notar que faltan son
- * el retardo al abrir, cerrarlo con Escape, **abrirlo también al enfocar**
- * —si solo abre al posar el ratón, para quien navega con el teclado no
- * existe— y describir el disparador con `aria-describedby`, que es lo que
- * hace que un lector de pantalla lo lea en vez de dejarlo suelto en la
- * página. Las cuatro están abajo, cada una con su prueba.
- */
-type Props = {
-    /** Milisegundos antes de abrirse al posar el ratón. */
-    delay?: number;
-    disabled?: boolean;
-    /** Dónde montar el aviso. Por defecto, lo que provea el modal que envuelva. */
-    portal?: VunoPortalTarget;
-    side?: 'bottom' | 'left' | 'right' | 'top';
-    text?: string;
-    ui?: VunoUi<'tooltip'>;
-};
+import type { VunoTooltipProps } from './Tooltip.types.js';
 type __VLS_Slots = {
     default?: () => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<VunoTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoTooltipProps> & Readonly<{}>, {
     text: string;
-    ui: VunoUi<"tooltip">;
+    ui: import("../../types/slots.js").VunoUi<"tooltip">;
     delay: number;
-    portal: VunoPortalTarget;
-    side: "bottom" | "left" | "right" | "top";
+    portal: import("../../types/base.js").VunoPortalTarget;
+    side: import("./Tooltip.types.js").VunoTooltipSide;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

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

@@ -0,0 +1,11 @@
+import type { VunoPlacement, VunoPortalTarget } from '#vuno/types/base';
+import type { VunoUi } from '#vuno/types/slots';
+export type VunoTooltipSide = Extract<VunoPlacement, 'bottom' | 'left' | 'right' | 'top'>;
+export type VunoTooltipProps = {
+    delay?: number;
+    disabled?: boolean;
+    portal?: VunoPortalTarget;
+    side?: VunoTooltipSide;
+    text?: string;
+    ui?: VunoUi<'tooltip'>;
+};

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

@@ -3,7 +3,7 @@ import { cloneVNode, computed, nextTick, onBeforeUnmount, ref, useId } from "vue
 import { useVunoAnchor } from "#vuno/composables/internal/useVunoAnchor";
 import { useVunoPortal } from "#vuno/composables/internal/useVunoPortal";
 import { useTheme } from "#vuno/composables/useTheme";
-import { firstElement } from "#vuno/internal/slots";
+import { firstElement } from "#vuno/utils/slots";
 defineOptions({ name: "VunoTooltip" });
 const props = defineProps({
   delay: { type: Number, required: false, default: 300 },

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

@@ -1,34 +1,13 @@
-import type { VunoPortalTarget } from '#vuno/types/base';
-import type { VunoUi } from '#vuno/types/slots';
-/**
- * El aviso que aparece al posar el ratón o al llegar con el teclado.
- *
- * Las cuatro cosas fáciles de dejarse y difíciles de notar que faltan son
- * el retardo al abrir, cerrarlo con Escape, **abrirlo también al enfocar**
- * —si solo abre al posar el ratón, para quien navega con el teclado no
- * existe— y describir el disparador con `aria-describedby`, que es lo que
- * hace que un lector de pantalla lo lea en vez de dejarlo suelto en la
- * página. Las cuatro están abajo, cada una con su prueba.
- */
-type Props = {
-    /** Milisegundos antes de abrirse al posar el ratón. */
-    delay?: number;
-    disabled?: boolean;
-    /** Dónde montar el aviso. Por defecto, lo que provea el modal que envuelva. */
-    portal?: VunoPortalTarget;
-    side?: 'bottom' | 'left' | 'right' | 'top';
-    text?: string;
-    ui?: VunoUi<'tooltip'>;
-};
+import type { VunoTooltipProps } from './Tooltip.types.js';
 type __VLS_Slots = {
     default?: () => unknown;
 };
-declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<VunoTooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VunoTooltipProps> & Readonly<{}>, {
     text: string;
-    ui: VunoUi<"tooltip">;
+    ui: import("../../types/slots.js").VunoUi<"tooltip">;
     delay: number;
-    portal: VunoPortalTarget;
-    side: "bottom" | "left" | "right" | "top";
+    portal: import("../../types/base.js").VunoPortalTarget;
+    side: import("./Tooltip.types.js").VunoTooltipSide;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

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

@@ -0,0 +1,5 @@
+import type { InjectionKey } from 'vue';
+import type { VunoContext } from '#vuno/types/app';
+export declare const vunoContextInjectionKey: InjectionKey<VunoContext>;
+export declare function provideVunoContext(context: VunoContext): void;
+export declare function useVunoContext(): null | VunoContext;

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

@@ -0,0 +1,8 @@
+import { inject, provide } from "vue";
+export const vunoContextInjectionKey = Symbol("vuno-context");
+export function provideVunoContext(context) {
+  provide(vunoContextInjectionKey, context);
+}
+export function useVunoContext() {
+  return inject(vunoContextInjectionKey, null);
+}

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

@@ -1,16 +1,15 @@
 import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
-import type { VunoSize } from '#vuno/types/base';
-import type { VunoControlOrientation } from '#vuno/types/field';
+import type { VunoControlOrientation, VunoFieldSize } from '#vuno/types/field';
 type VunoControlGroupContext = {
     orientation?: VunoControlOrientation;
-    size?: VunoSize;
+    size?: VunoFieldSize;
 };
 /** 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>;
+    size: ComputedRef<VunoFieldSize | undefined>;
 };
 /** Impide que las acciones internas de un control se comporten como hijos del grupo exterior. */
 export declare function resetControlGroup(): void;

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

@@ -0,0 +1,5 @@
+type VunoDirection = 'ltr' | 'rtl';
+type VunoDirectionProvider = () => VunoDirection;
+export declare function provideVunoDirection(direction: VunoDirectionProvider): void;
+export declare function useVunoDirection(): VunoDirectionProvider;
+export {};

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

@@ -0,0 +1,8 @@
+import { inject, provide } from "vue";
+const vunoDirectionInjectionKey = Symbol("vuno-direction");
+export function provideVunoDirection(direction) {
+  provide(vunoDirectionInjectionKey, direction);
+}
+export function useVunoDirection() {
+  return inject(vunoDirectionInjectionKey, () => "ltr");
+}

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

@@ -0,0 +1,5 @@
+import type { InjectionKey } from 'vue';
+import type { VunoFormContext, VunoFormState } from '#vuno/types/form';
+export declare const vunoFormInjectionKey: InjectionKey<VunoFormContext>;
+export declare function provideVunoFormContext<TState extends VunoFormState>(context: VunoFormContext<TState>): void;
+export declare function useVunoFormContext<TState extends VunoFormState>(): null | VunoFormContext<TState>;

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

@@ -0,0 +1,8 @@
+import { inject, provide } from "vue";
+export const vunoFormInjectionKey = Symbol("vuno-form");
+export function provideVunoFormContext(context) {
+  provide(vunoFormInjectionKey, context);
+}
+export function useVunoFormContext() {
+  return inject(vunoFormInjectionKey, null);
+}

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

@@ -0,0 +1,6 @@
+import type { InjectionKey } from 'vue';
+type VunoOverlayBehindProvider = () => boolean;
+export declare const vunoOverlayBehindInjectionKey: InjectionKey<VunoOverlayBehindProvider>;
+export declare function provideVunoOverlayBehind(behind: VunoOverlayBehindProvider): void;
+export declare function useVunoOverlayBehind(): VunoOverlayBehindProvider;
+export {};

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

@@ -0,0 +1,8 @@
+import { inject, provide } from "vue";
+export const vunoOverlayBehindInjectionKey = Symbol("vuno-overlay-behind");
+export function provideVunoOverlayBehind(behind) {
+  provide(vunoOverlayBehindInjectionKey, behind);
+}
+export function useVunoOverlayBehind() {
+  return inject(vunoOverlayBehindInjectionKey, () => false);
+}

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

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

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

@@ -1,7 +1,6 @@
-import { inject } from "vue";
-import { vunoFormInjectionKey } from "#vuno/internal/keys";
+import { useVunoFormContext } from "#vuno/composables/internal/useVunoFormContext";
 export function useForm(options) {
-  const form = inject(vunoFormInjectionKey, null);
+  const form = useVunoFormContext();
   if (!form && !options?.optional) {
     throw new Error("[Vuno] useForm() debe utilizarse dentro de <VForm>.");
   }

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

@@ -1,7 +1,7 @@
 import { type Ref } from 'vue';
 import type { VunoTableQuery, VunoTableQueryOptions } from '#vuno/types/table';
 /**
- * Estado de consulta para `<VTable v-model:query>`.
+ * Estado de consulta para `<VDataTable v-model:query>`.
  *
  * Sin `url` es un `ref` normal. Con `url: true` se sincroniza en los dos
  * sentidos con la query string, de modo que navegar atrás o pegar el enlace

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

@@ -1,13 +1,16 @@
 import { computed, toValue } from "vue";
 import { useAppConfig } from "#imports";
 import { defaultIcons, defaultMessages, defaultTheme } from "#vuno/theme";
-import { mergeSlots, selectCompoundVariants, selectVariants } from "#vuno/utils/theme";
+import { mergeSlots, resolveTheme } 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));
+    const requested = toValue(variants);
+    const active = { ...requested, radius: requested?.radius ?? vuno.value.theme?.radius };
+    const component = entry(vuno.value.components ?? {});
+    const base = entry(defaultTheme);
+    const merged = mergeSlots(resolveTheme(base, active), resolveTheme(component, active, Object.keys(base?.slots ?? {})), toValue(ui));
     return merged;
   });
 }

package/dist/runtime/app/{components/internal/ControlShell/ControlShell.vue.d.ts → primitives/PrimitiveControl/PrimitiveControl.d.vue.ts}

@@ -1,4 +1,5 @@
-import type { VunoRadius, VunoSize } from '#vuno/types/base';
+import type { VunoRadius } from '#vuno/types/base';
+import type { VunoFieldSize } from '#vuno/types/field';
 import type { VunoUi } from '#vuno/types/slots';
 /**
  * La caja de un control: borde, fondo, foco, inválido y deshabilitado.
@@ -15,7 +16,7 @@ import type { VunoUi } from '#vuno/types/slots';
 type Props = {
     /** La curvatura. Sin valor, la que traiga el tema. */
     radius?: VunoRadius;
-    size?: VunoSize;
+    size?: VunoFieldSize;
     ui?: VunoUi<'control'>;
 };
 type __VLS_Slots = {
@@ -28,7 +29,7 @@ type __VLS_Slots = {
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     radius: VunoRadius;
-    size: VunoSize;
+    size: VunoFieldSize;
     ui: VunoUi<"control">;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/runtime/app/{components/internal/ControlShell/ControlShell.theme.d.ts → primitives/PrimitiveControl/PrimitiveControl.theme.d.ts}

@@ -28,7 +28,7 @@ export declare const controlTheme: Record<"control", {
                 readonly root: "not-last:not-first:rounded-none not-only:first:rounded-b-none not-only:last:rounded-t-none focus-within:z-1";
             };
         };
-        readonly radius: Record<import("../../../types/base.js").VunoRadius, Record<"root", string>>;
+        readonly radius: Record<import("../../types/base.js").VunoRadius, Record<"root", string>>;
         readonly size: {
             readonly xs: {
                 readonly root: "min-h-6 ps-2 pe-2 text-xs";

package/dist/runtime/app/{components/internal/ControlShell/ControlShell.vue → primitives/PrimitiveControl/PrimitiveControl.vue}

@@ -2,7 +2,7 @@
 import { computed } from "vue";
 import { resetControlGroup, useVunoControlGroup } from "#vuno/composables/internal/useVunoControlGroup";
 import { useTheme } from "#vuno/composables/useTheme";
-defineOptions({ name: "VunoControlShell" });
+defineOptions({ name: "VunoPrimitiveControl" });
 const props = defineProps({
   radius: { type: String, required: false, default: void 0 },
   size: { type: String, required: false, default: void 0 },