@vasakgroup/vue-libvasak 0.3.5 → 0.4.0

package/dist/types/bar/BarSearch.vue.d.ts

@@ -0,0 +1,30 @@
+type __VLS_Props = {
+    modelValue?: string;
+    placeholder?: string;
+    /** Lo que oye un lector de pantalla en la lupa. */
+    label?: string;
+    /**
+     * Plegado aunque la barra sea horizontal.
+     *
+     * Vertical se pliega siempre: ahí no es una preferencia, es que no entra.
+     */
+    collapsed?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (valor: string) => any;
+    close: () => any;
+    "update:modelValue": (valor: string) => any;
+    open: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSearch?: ((valor: string) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((valor: string) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {
+    label: string;
+    collapsed: boolean;
+    modelValue: string;
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/index.d.ts

@@ -4,6 +4,11 @@ import SideGroup from "./sidebar/SideGroup.vue";
 import SelectField from "./forms/SelectField.vue";
 import ThemeIcon from "./icons/ThemeIcon.vue";
 import WindowFrame from "./window/WindowFrame.vue";
+import AppBar from "./window/AppBar.vue";
+import WindowControls from "./window/WindowControls.vue";
+import TabBar from "./tabs/TabBar.vue";
+import TabItem from "./tabs/TabItem.vue";
+import BarSearch from "./bar/BarSearch.vue";
 import ActionButton from "./controls/ActionButton.vue";
 import ConfigSection from "./layout/ConfigSection.vue";
 import DeviceCard from "./cards/DeviceCard.vue";
@@ -18,5 +23,9 @@ declare const _default: {
     install(app: App): void;
 };
 export default _default;
-export { SideBar, SideButton, SideGroup, SelectField, ThemeIcon, WindowFrame, ActionButton, ConfigSection, DeviceCard, FormGroup, ListCard, SliderControl, SwitchToggle, ToggleControl, TrayIconButton, };
+export { SideBar, SideButton, SideGroup, SelectField, ThemeIcon, WindowFrame, AppBar, WindowControls, TabBar, TabItem, BarSearch, ActionButton, ConfigSection, DeviceCard, FormGroup, ListCard, SliderControl, SwitchToggle, ToggleControl, TrayIconButton, };
 export type { SidebarCategory, SidebarItem } from "./sidebar/tipos";
+export type { AccionDePestana, ElementoDePestana } from "./tabs/tipos";
+export type { ContextoDeLaBarra, OrientacionDeLaBarra, PosicionDeLaBarra, } from "./window/tipos";
+export { CLAVE_DE_LA_BARRA, esPosicion, orientacionDe, POSICIONES, usarLaBarra } from "./window/tipos";
+export { posicionDe, usarLaPosicionDeLaBarra } from "./window/preferencia";

package/dist/types/tabs/TabBar.vue.d.ts

@@ -0,0 +1,44 @@
+import type { ElementoDePestana } from './tipos';
+type __VLS_Props = {
+    tabs: ElementoDePestana[];
+    /** El identificador de la activa. */
+    modelValue?: string;
+    /** Sin esto no se dibuja el botón de pestaña nueva. */
+    newLabel?: string;
+    closeLabel?: string;
+    /** Lo que se oye en una pestaña con cambios sin guardar. */
+    dirtyLabel?: string;
+    /** Para una barra que no deja reordenar. */
+    fixedOrder?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    menu: (carga: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any;
+    select: (id: string) => any;
+    close: (id: string) => any;
+    "update:modelValue": (id: string) => any;
+    new: () => any;
+    reorder: (tabs: ElementoDePestana[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMenu?: ((carga: {
+        id: string;
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    onSelect?: ((id: string) => any) | undefined;
+    onClose?: ((id: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((id: string) => any) | undefined;
+    onNew?: (() => any) | undefined;
+    onReorder?: ((tabs: ElementoDePestana[]) => any) | undefined;
+}>, {
+    modelValue: string;
+    closeLabel: string;
+    dirtyLabel: string;
+    newLabel: string;
+    fixedOrder: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/tabs/TabItem.vue.d.ts

@@ -0,0 +1,43 @@
+import type { ElementoDePestana } from './tipos';
+type __VLS_Props = {
+    tab: ElementoDePestana;
+    active?: boolean;
+    closeLabel?: string;
+    /**
+     * Lo que se dice de una pestaña con cambios sin guardar.
+     *
+     * El punto es lo único que lo indicaba, y va `aria-hidden`: quien usa un
+     * lector de pantalla podía cerrar una pestaña modificada sin enterarse.
+     * Entra por propiedad porque una librería que traduce obliga a todas las
+     * aplicaciones a compartir sus claves.
+     */
+    dirtyLabel?: string;
+    /** El índice dentro de la barra, para el foco itinerante. */
+    tabindex?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    menu: (posicion: {
+        x: number;
+        y: number;
+    }) => any;
+    select: () => any;
+    close: () => any;
+    mover: (cuanto: 1 | -1) => any;
+    navegar: (a: "anterior" | "siguiente" | "primera" | "ultima") => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMenu?: ((posicion: {
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    onSelect?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onMover?: ((cuanto: 1 | -1) => any) | undefined;
+    onNavegar?: ((a: "anterior" | "siguiente" | "primera" | "ultima") => any) | undefined;
+}>, {
+    active: boolean;
+    closeLabel: string;
+    dirtyLabel: string;
+    tabindex: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/tabs/tipos.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Una pestaña, tal como la dibuja la barra compartida.
+ *
+ * El escritorio tenía tres barras de pestañas distintas —la terminal, el gestor
+ * de archivos y el editor de texto— con prestaciones que no se solapaban: el
+ * editor era el único con el punto de «sin guardar», la terminal la única con
+ * vista previa al pasar por encima, y el menú de «cerrar las demás» estaba en
+ * dos de las tres. Esto es la unión, para que una pestaña se comporte igual en
+ * cualquier ventana.
+ */
+export interface ElementoDePestana {
+    id: string;
+    /** Lo que se lee. Si se corta, el `title` lo dice entero. */
+    label: string;
+    /** Un nombre del tema de iconos del escritorio, no una ruta. */
+    icon?: string;
+    /**
+     * Tiene cambios sin guardar.
+     *
+     * Se dibuja como un punto y, si además se puede cerrar, el punto **es** el
+     * botón de cerrar hasta que el puntero pasa por encima: así no hay dos
+     * cosas peleando por el mismo lugar en una pestaña de ciento treinta y seis
+     * píxeles.
+     */
+    dirty?: boolean;
+    /** Por omisión se puede cerrar. */
+    closable?: boolean;
+    /** Lo que dice la vista previa al pasar por encima; sin esto, el `label`. */
+    tooltip?: string;
+}
+/** Una acción del menú contextual de una pestaña. */
+export interface AccionDePestana {
+    id: string;
+    label: string;
+    icon?: string;
+    /** Se dibuja apagada, pero sigue alcanzable para un lector de pantalla. */
+    disabled?: boolean;
+}

package/dist/types/window/AppBar.vue.d.ts

@@ -0,0 +1,38 @@
+import { type PosicionDeLaBarra } from './tipos';
+type __VLS_Props = {
+    /** Sin esto toma la del marco que la envuelve. */
+    position?: PosicionDeLaBarra | null;
+    title?: string;
+    /** Los nombres de los controles de ventana, traducidos por la aplicación. */
+    minimizeLabel?: string;
+    maximizeLabel?: string;
+    closeLabel?: string;
+    /** Para una ventana sin botones propios: un diálogo, un asistente. */
+    hideControls?: boolean;
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    identidad?: (props: typeof __VLS_1) => any;
+} & {
+    titulo?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+} & {
+    acciones?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    minimizeLabel: string;
+    maximizeLabel: string;
+    closeLabel: string;
+    position: PosicionDeLaBarra | null;
+    hideControls: 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/types/window/WindowControls.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    minimizeLabel?: string;
+    maximizeLabel?: string;
+    closeLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    minimizeLabel: string;
+    maximizeLabel: string;
+    closeLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/window/WindowFrame.vue.d.ts

@@ -1,14 +1,35 @@
+import { type PosicionDeLaBarra } from './tipos';
 type __VLS_Props = {
+    /** Fija la barra a un lado, ignorando la preferencia del escritorio. */
+    position?: PosicionDeLaBarra | null;
     title?: string;
-    image?: string;
+    minimizeLabel?: string;
+    maximizeLabel?: string;
+    closeLabel?: string;
+    hideControls?: boolean;
+    /** Para una ventana que dibuja su propia barra o no lleva ninguna. */
+    hideBar?: boolean;
 };
-declare var __VLS_6: {};
+declare var __VLS_8: {}, __VLS_11: {}, __VLS_14: {}, __VLS_16: {}, __VLS_18: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_6) => any;
+    identidad?: (props: typeof __VLS_8) => any;
+} & {
+    titulo?: (props: typeof __VLS_11) => any;
+} & {
+    acciones?: (props: typeof __VLS_14) => any;
+} & {
+    barra?: (props: typeof __VLS_16) => any;
+} & {
+    default?: (props: typeof __VLS_18) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     title: string;
-    image: string;
+    minimizeLabel: string;
+    maximizeLabel: string;
+    closeLabel: string;
+    position: PosicionDeLaBarra | null;
+    hideControls: boolean;
+    hideBar: boolean;
 }, {}, {}, {}, 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/types/window/preferencia.d.ts

@@ -0,0 +1,35 @@
+/**
+ * De dónde sale la posición de la barra.
+ *
+ * De `~/.config/vasak/vasak.conf`, en `window.barPosition`, que es la misma
+ * configuración del escritorio que ya traen las fuentes, el tema y los iconos.
+ * Que sea de ahí y no de cada aplicación es el punto: moverla en un lado la
+ * mueve en todas.
+ *
+ * # Por qué una clave que el plugin no declara
+ *
+ * `VSKConfig` no la tiene en su tipo, pero el modelo de Rust guarda todo lo que
+ * no conoce en un `serde(flatten)` y lo devuelve tal cual, así que la clave
+ * sobrevive a cada lectura y a cada escritura. Es el mismo camino por el que
+ * pasan los widgets del escritorio, que los escribe y los lee sólo el
+ * escritorio. Si algún día se vuelve parte del tipo, esto sigue andando.
+ *
+ * # Y por qué tolera que no haya nada
+ *
+ * Una ventana se dibuja antes de que la configuración llegue, y puede abrirse
+ * fuera de Tauri —una prueba, una vista previa— donde no hay configuración
+ * ninguna. En los dos casos la respuesta es «arriba», que es donde la barra
+ * estuvo siempre.
+ */
+import { type Ref } from 'vue';
+import { type PosicionDeLaBarra } from './tipos';
+/** Saca la posición de una configuración ya leída, o `null` si no dice nada. */
+export declare function posicionDe(configuracion: unknown): PosicionDeLaBarra | null;
+/**
+ * La posición de la barra, siguiendo a la configuración.
+ *
+ * Se vuelve a leer con cada `config-changed`, que es el evento que el gestor de
+ * configuración emite al guardar: mover la barra en Configuración la mueve en
+ * las ventanas abiertas sin cerrarlas.
+ */
+export declare function usarLaPosicionDeLaBarra(porOmision?: PosicionDeLaBarra): Ref<PosicionDeLaBarra>;

package/dist/types/window/tipos.d.ts

@@ -0,0 +1,48 @@
+/**
+ * El contrato entre el marco de la ventana y lo que vive en su barra.
+ *
+ * La barra puede quedar arriba, abajo, a la izquierda o a la derecha, y lo que
+ * se pone adentro tiene que amoldarse: unas pestañas que se desbordan a lo
+ * ancho no se desbordan igual a lo alto, y un campo de texto de doscientos
+ * píxeles no entra en una barra de cuarenta y ocho.
+ *
+ * El marco lo **provee** y los componentes lo **inyectan**, en vez de que cada
+ * aplicación baje la orientación por propiedades hasta el último nieto. Eso es
+ * lo que permite que una barra de pestañas escrita en su repositorio se amolde
+ * sin que nadie la toque.
+ */
+import { type InjectionKey, type Ref } from 'vue';
+/** Dónde queda la barra dentro de la ventana. */
+export type PosicionDeLaBarra = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Cómo se acomoda lo que va adentro.
+ *
+ * Es lo que la mayoría de los componentes necesita saber: arriba y abajo se
+ * comportan igual, y la izquierda y la derecha también.
+ */
+export type OrientacionDeLaBarra = 'horizontal' | 'vertical';
+export interface ContextoDeLaBarra {
+    posicion: Ref<PosicionDeLaBarra>;
+    orientacion: Ref<OrientacionDeLaBarra>;
+    /** `true` cuando la barra es vertical, que es lo que más se pregunta. */
+    vertical: Ref<boolean>;
+}
+export declare const CLAVE_DE_LA_BARRA: InjectionKey<ContextoDeLaBarra>;
+/** La orientación de las cuatro posiciones. */
+export declare function orientacionDe(posicion: PosicionDeLaBarra): OrientacionDeLaBarra;
+/** Las cuatro, para validar lo que venga de la configuración. */
+export declare const POSICIONES: readonly PosicionDeLaBarra[];
+export declare function esPosicion(valor: unknown): valor is PosicionDeLaBarra;
+/**
+ * La orientación de la barra que envuelve a este componente.
+ *
+ * Fuera de un marco devuelve horizontal: un componente de barra montado suelto
+ * —en una prueba, en una vista previa— tiene que dibujarse igual, no reventar.
+ *
+ * Los tres son `ref` de verdad y no objetos con una propiedad `value`. Vue
+ * desenvuelve en la plantilla lo que **es** una ref; un objeto que se le
+ * parece llega entero, y un objeto siempre es verdadero: con el respaldo
+ * falsificado, `vertical` daba verdadero y todo lo que se montara fuera de un
+ * marco se dibujaba de costado. Lo encontró una prueba de `aria-orientation`.
+ */
+export declare function usarLaBarra(): ContextoDeLaBarra;