@seniorsistemas/angular-components 19.9.8 → 19.9.10

package/select/lib/select/select.component.d.ts

@@ -1,4 +1,4 @@
-import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { AfterViewInit, OnDestroy, OnInit, Signal } from '@angular/core';
 import { ControlValueAccessor, FormControl, FormGroup } from '@angular/forms';
 import * as i0 from "@angular/core";
 interface InternalDropdownOption<T> {
@@ -69,7 +69,7 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * Prioriza o valor explícito de `ariaLabelledBy`; caso contrário, usa o id de um
      * `<label for="...">` externo associado ao host (detectado em runtime).
      */
-    readonly resolvedAriaLabelledBy: import("@angular/core").Signal<string>;
+    readonly resolvedAriaLabelledBy: Signal<string>;
     value: import("@angular/core").WritableSignal<InternalDropdownOption<T> | null>;
     values: import("@angular/core").WritableSignal<InternalDropdownOption<T>[]>;
     filterValue: import("@angular/core").WritableSignal<string>;
@@ -83,17 +83,23 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * na lista de valores selecionados, e `false` caso contrário.
      * @returns {boolean} `true` se todas as opções filtradas estão selecionadas, `false` caso contrário.
      */
-    allSelected: import("@angular/core").Signal<boolean>;
+    allSelected: Signal<boolean>;
+    /**
+     * Label de acessibilidade do checkbox "Selecionar Todos", contextual ao estado atual —
+     * reportado: sem `ariaLabel` explícito, o leitor de tela só anunciava "checkbox, não
+     * marcado", sem indicar a ação (selecionar ou desmarcar todas as opções).
+     */
+    readonly selectAllCheckboxAriaLabel: Signal<any>;
     /**
      * Retorna o item atualmente focado na lista de opções filtradas.
      * @returns O dado do item focado ou `null` caso nenhum item esteja focado.
      */
-    focusedItem: import("@angular/core").Signal<NonNullable<T> | null>;
+    focusedItem: Signal<NonNullable<T> | null>;
     /**
      * Retorna o item atualmente focado na lista de opções filtradas.
      * @returns O dado do item focado ou `null` caso nenhum item esteja focado.
      */
-    focusedOptionId: import("@angular/core").Signal<string | null>;
+    focusedOptionId: Signal<string | null>;
     /**
      * Computa e retorna a lista interna de opções do dropdown.
      * - Se as opções estiverem agrupadas (`group()` retorna verdadeiro),
@@ -101,7 +107,7 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * - Caso contrário, retorna as opções com IDs adicionados.
      * @returns Um array de `InternalDropdownOption<T>` representando as opções disponíveis para o componente select.
      */
-    internalOptions: import("@angular/core").Signal<InternalDropdownOption<T>[]>;
+    internalOptions: Signal<InternalDropdownOption<T>[]>;
     /**
      * Retorna uma string representando a seleção atual do componente.
      * - Se o modo múltiplo estiver ativado e mais de um item estiver selecionado,
@@ -110,21 +116,21 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * - Se o modo múltiplo não estiver ativado, retorna o rótulo do item selecionado ou uma string vazia caso nenhum item esteja selecionado.
      * @returns {string} Texto representando a seleção atual.
      */
-    print: import("@angular/core").Signal<any>;
+    print: Signal<any>;
     /**
      * Indica se o seletor está "limpo", ou seja, sem nenhum valor selecionado.
      * - No modo múltiplo (`multiple`), retorna `true` se não houver nenhum valor selecionado (`values` está vazio).
      * - No modo simples, retorna `true` se não houver valor selecionado (`value` é falsy).
      * @returns `true` se não houver seleção, `false` caso contrário.
      */
-    isClean: import("@angular/core").Signal<boolean>;
+    isClean: Signal<boolean>;
     /**
      * Computed que indica se o estado de seleção "Selecionar Todos" está indeterminado.
      * Retorna `true` quando nem todos os itens filtrados estão selecionados e nem todos estão desmarcados,
      * ou seja, quando há uma seleção parcial dos itens disponíveis.
      * @returns {boolean} `true` se a seleção for parcial, `false` caso contrário.
      */
-    selectAllIsIndeterminate: import("@angular/core").Signal<boolean>;
+    selectAllIsIndeterminate: Signal<boolean>;
     /**
      * Retorna uma lista de opções filtradas com base no valor de busca (`filterValue`) e nos critérios definidos.
      * - Se o filtro estiver desabilitado ou o valor de busca estiver vazio, retorna todas as opções.
@@ -132,19 +138,43 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * - Ignora opções que possuem a propriedade `grouper` definida.
      * @returns As opções filtradas conforme o valor de busca e critérios de filtro.
      */
-    filteredOptions: import("@angular/core").Signal<InternalDropdownOption<T>[]>;
+    filteredOptions: Signal<InternalDropdownOption<T>[]>;
+    /**
+     * Mapeia o id de cada opção que é a PRIMEIRA de um grupo (`group()` habilitado) ao texto
+     * anunciado via `aria-describedby` (ex.: "Agrupado por América do Sul"). O agrupador visual
+     * tem `role="presentation"` (silencioso pro leitor de tela) — reportado: ao navegar pra
+     * dentro de um grupo, nada indicava a que grupo a opção pertencia. Só a primeira opção de
+     * cada grupo recebe o anúncio, pra não repetir a cada opção subsequente do mesmo grupo.
+     */
+    readonly groupAnnouncements: Signal<Map<string, string>>;
+    /**
+     * Mapeia o id de cada opção à sua posição (`posinset`) e ao tamanho total do conjunto
+     * (`setsize`), ignorando agrupadores (que não são `role="option"`). Necessário porque, com
+     * `virtualScroll`, só uma janela de opções existe de fato no DOM a cada momento — sem
+     * `aria-posinset`/`aria-setsize` explícitos, o leitor de tela tenta inferir a posição
+     * contando os `role="option"` irmãos presentes no DOM, o que fica errado pra uma lista
+     * virtualizada (reportado via NVDA: ao selecionar a 3ª opção de uma lista de ~240 países
+     * com `virtualScroll`, o anúncio de posição "voltava" pra 1 antes de se corrigir).
+     */
+    readonly optionPositions: Signal<Map<string, {
+        posinset: number;
+        setsize: number;
+    }>>;
     readonly filterForm: FormGroup<{
         filter: FormControl<string>;
     }>;
     private readonly _containerDiv;
     private readonly _filterInput;
     private readonly _selectAllCheckbox;
+    private readonly _dropdownPanel;
     private _onChange;
     private _onTouched;
     private _clickableLabel;
     private readonly _translateService;
     private readonly _hostRef;
     private readonly _renderer;
+    private readonly _injector;
+    private readonly _liveAnnouncer;
     constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
@@ -194,6 +224,13 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * Sempre notifica as mudanças e marca o componente como tocado.
      */
     selectItem(item: InternalDropdownOption<T>): void;
+    /**
+     * Anuncia via `LiveAnnouncer` a opção selecionada/desmarcada. Necessário porque, na prática,
+     * nem todo navegador/leitor de tela anuncia sozinho a mudança de `aria-selected` da opção
+     * apontada por `aria-activedescendant` (reportado via NVDA no Chrome: nenhuma mensagem era
+     * ouvida ao selecionar).
+     */
+    private _announceOptionToggle;
     /**
      * Limpa o valor selecionado no componente select.
      * Se o componente estiver desabilitado, não executa nenhuma ação.
@@ -226,16 +263,33 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * Manipula eventos de teclado no input de filtro do overlay.
      * - 'ArrowDown': Move o foco para a primeira opção da lista.
      * - 'ArrowUp': Move o foco para a última opção da lista.
+     * - 'Tab' (sem Shift): Move o foco para a próxima opção da lista, em vez de deixar o Tab
+     *   nativo tentar sair do overlay (as opções não são elementos tabuláveis, então o Tab
+     *   nativo "vazava" o foco pra fora do painel sem nunca alcançar a lista).
      * - 'Escape': Fecha o dropdown e retorna o foco ao combobox.
-     * - 'Enter': Seleciona a opção focada, se houver.
+     * - 'Enter' / 'Espaço': Seleciona a opção focada, se houver. Espaço só é interceptado
+     *   quando já existe uma opção com foco virtual (`focusedIndex() >= 0`) — sem uma opção
+     *   focada, o espaço é deixado passar pro comportamento nativo do `<input>` (digitar um
+     *   espaço, necessário pra buscas com múltiplas palavras).
      * @param event O evento de teclado disparado no input de filtro.
      */
     onFilterKeyDown(event: KeyboardEvent): void;
+    /**
+     * Manipula o evento de teclado no botão "Limpar filtro" do overlay.
+     * É o último controle real (tabulável) do overlay antes da lista de opções — sem
+     * interceptar o Tab aqui, ele "vazava" o foco pra fora do painel sem nunca alcançar a
+     * lista, já que as opções não são elementos tabuláveis (foco virtual via
+     * aria-activedescendant).
+     * @param event O evento de teclado disparado no botão.
+     */
+    onClearFilterButtonKeyDown(event: KeyboardEvent): void;
     /**
      * Manipula eventos de teclado para navegação e seleção de opções no componente select.
      * - 'ArrowDown': Move o foco para a próxima opção disponível.
      * - 'ArrowUp': Move o foco para a opção anterior.
-     * - 'Tab': Seleciona a opção atualmente focada e fecha o dropdown.
+     * - 'Tab'/'Shift+Tab': Com o dropdown aberto e sem filtro, navega entre as opções (mesmo
+     *   efeito de ArrowDown/ArrowUp) em vez de fechar o painel e "vazar" o foco pro próximo
+     *   campo da página sem o usuário nunca ter alcançado as opções.
      * - 'Enter': Seleciona a opção focada se o dropdown estiver aberto, ou alterna a abertura do dropdown.
      * - 'Escape': Fecha o dropdown.
      * - ' ': (barra de espaço) Seleciona a opção focada se o dropdown estiver aberto, ou alterna a abertura do dropdown.
@@ -249,6 +303,25 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * @returns O rótulo da opção como uma string.
      */
     getOptionLabel(option: T): string;
+    /**
+     * Retorna o texto de anúncio de grupo (ex.: "Agrupado por América do Sul") pra uma opção,
+     * caso ela seja a primeira do seu grupo — ver `groupAnnouncements`.
+     * @param optionId Id da opção interna.
+     * @returns O texto de anúncio, ou `null` se a opção não for a primeira do grupo.
+     */
+    groupAnnouncementFor(optionId: string): string | null;
+    /**
+     * Retorna a posição (1-based) de uma opção dentro do conjunto navegável — ver `optionPositions`.
+     * @param optionId Id da opção interna.
+     * @returns A posição, ou `null` se a opção não for encontrada (ex.: é um agrupador).
+     */
+    optionPosinsetFor(optionId: string): number | null;
+    /**
+     * Retorna o tamanho total do conjunto navegável ao qual uma opção pertence — ver `optionPositions`.
+     * @param optionId Id da opção interna.
+     * @returns O tamanho total, ou `null` se a opção não for encontrada (ex.: é um agrupador).
+     */
+    optionSetsizeFor(optionId: string): number | null;
     /**
      * Função de trackBy utilizada em blocos @for para otimizar a renderização de listas.
      * Retorna o identificador único (`id`) de cada item do tipo `InternalDropdownOption<T>`.
@@ -270,6 +343,14 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
      * Após a alteração, notifica a mudança de valor.
      */
     toggleSelectAll(): void;
+    /**
+     * Anuncia via `LiveAnnouncer` o resultado de "Selecionar Todos"/"Limpar Todos". Necessário
+     * porque o checkbox que dispara a ação tem foco real e anuncia seu próprio `aria-checked`
+     * normalmente, mas as N opções afetadas (que não estão focadas) não — ao contrário do toggle
+     * de uma opção individual, cujo `aria-selected` já é lido pelo leitor de tela porque ela é o
+     * elemento apontado por `aria-activedescendant` no momento da mudança.
+     */
+    private _announceSelectAllToggle;
     /**
      * Retorna o rótulo (label) de uma opção fornecida.
      * Este método utiliza a propriedade definida por `optionLabel` para extrair o valor do rótulo da opção.
@@ -318,15 +399,28 @@ export declare class SelectComponent<T> implements ControlValueAccessor, OnInit,
     /**
      * Fecha o dropdown de opções do componente select.
      * Este método oculta as opções disponíveis e redefine o índice do item focado para -1,
-     * indicando que nenhum item está atualmente focado.
-     * @private
+     * indicando que nenhum item está atualmente focado. Se o foco estava dentro do painel
+     * sendo fechado (ex.: campo de filtro), devolve o foco pro container/combobox — nunca
+     * força o foco se ele já estiver em outro lugar (ex.: opção escolhida via clique do mouse
+     * sem filtro, onde o foco DOM nunca saiu do combobox por causa do aria-activedescendant).
+     * `protected` (não `private`) porque também é chamado a partir do template
+     * (`backdropClick`/`detach` do `cdkConnectedOverlay`).
      */
-    private _closeDropdown;
+    protected _closeDropdown(): void;
     /**
      * Adiciona um identificador único a cada opção fornecida.
      * Para cada item no array de opções, gera um objeto `InternalDropdownOption` contendo o dado original
-     * e um campo `id` único baseado no timestamp atual e no índice do item. Caso a opção seja um grupo
-     * (detectado pela presença de um array `items`), adiciona também a propriedade `grouper: true`.
+     * e um campo `id` único baseado no `componentId` desta instância, no timestamp atual e no índice do
+     * item. Caso a opção seja um grupo (detectado pela presença de um array `items`), adiciona também a
+     * propriedade `grouper: true`.
+     *
+     * O `componentId` é obrigatório no prefixo: `Date.now()` sozinho tem resolução de apenas 1ms, e duas
+     * instâncias de `s-select` na mesma página frequentemente inicializam dentro do mesmo milissegundo
+     * (confirmado via teste manual — reportado via NVDA: uma opção já selecionada em OUTRO `s-select` da
+     * página era anunciada em vez da opção de fato clicada). Sem o `componentId`, os ids colidiam entre
+     * instâncias diferentes (`id_<mesmo-timestamp>_0` em ambas), e `aria-activedescendant`/`getElementById`
+     * resolviam pro elemento errado — de outro select. O timestamp continua no id (além do `componentId`)
+     * pra manter ids únicos entre recomputações da MESMA instância quando `options()` muda de referência.
      * @private
      * @param options Array de opções do tipo `T` a serem processadas.
      * @returns Um array de objetos `InternalDropdownOption<T>` com identificadores únicos.

package/slider/lib/slider/slider.component.d.ts

@@ -113,19 +113,35 @@ export declare class SliderComponent implements OnInit, AfterViewInit, ControlVa
      */
     private mapRangeValuesForSlider;
     private activeMouseDown;
-    private focusActive;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngAfterViewInit(): void;
-    onKeydown($event: KeyboardEvent): void;
+    /**
+     * Handles arrow-key navigation for a single thumb. Each thumb owns its own keydown
+     * handler (instead of a shared `document:keydown` listener) so that Left/Right only
+     * move the thumb that currently has keyboard focus — never both at once.
+     */
+    onThumbKeydown(event: KeyboardEvent, thumb: 'start' | 'end'): void;
+    /**
+     * Returns the current user-facing value represented by the given thumb.
+     */
+    getThumbValue(thumb: 'start' | 'end'): number;
+    /**
+     * The "start" thumb can never move past the "end" thumb, so its effective minimum
+     * stays at `min` but its maximum is capped by the "end" thumb's current value.
+     */
+    getThumbMin(thumb: 'start' | 'end'): number;
+    /**
+     * Mirror of {@link getThumbMin}: the "end" thumb's minimum is capped by the "start"
+     * thumb's current value, so the two thumbs can never cross each other.
+     */
+    getThumbMax(thumb: 'start' | 'end'): number;
     get tooltipStartText(): string;
     get tooltipEndText(): string;
     writeValue(obj: number | [number, number]): void;
     registerOnChange(fn: (value: number | [number, number]) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
-    onFocusIn(): void;
-    onBlur(): void;
     onTrackClick(evt: MouseEvent): void;
     onProgressMouseDown(evt: MouseEvent): void;
     onMouseDown(_: MouseEvent, thumb: 'start' | 'end'): void;
@@ -159,9 +175,11 @@ export declare class SliderComponent implements OnInit, AfterViewInit, ControlVa
      * @returns The key that corresponds to the closest mapped value.
      */
     private getClosestValueFromMapSlider;
-    private handleArrowKeyLeft;
-    private handleArrowKeyRight;
-    private _incrementOrDecrementStartAndEndValue;
+    /**
+     * Moves only the given thumb by one `step`, clamped so it never crosses the other
+     * thumb (start ≤ end always) nor the slider's global `min`/`max`.
+     */
+    private _incrementOrDecrementSingleThumb;
     private _incrementOrDecrementEndValue;
     private get needParseValues();
     static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;

package/styles.css

@@ -1,4 +1,9 @@
 @import '@angular/cdk/overlay-prebuilt.css';
+
+:root {
+    --s-focus-ring-color: #0090ff;
+}
+
 body .p-datepicker-dropdown {
     border-width: 1px !important;
 }

package/switch/lib/switch/switch.component.d.ts

@@ -37,8 +37,6 @@ export declare class SwitchComponent implements ControlValueAccessor {
     switchRef: ElementRef;
     private _onChange?;
     private _onTouched?;
-    onFocusIn(): void;
-    onFocusOut(): void;
     writeValue(value: boolean): void;
     registerOnChange(onChange: (value: boolean) => void): void;
     registerOnTouched(onTouched: (value: boolean) => void): void;

package/thumbnail/lib/thumbnail/thumbnail.component.d.ts

@@ -43,6 +43,7 @@ export declare class ThumbnailComponent implements AfterViewInit, OnDestroy {
     isBrand: boolean;
     private ngUnsubscribe;
     ngOnDestroy(): void;
+    onContainerKeydown(event: KeyboardEvent): void;
     ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ThumbnailComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ThumbnailComponent, "s-thumbnail", never, { "id": { "alias": "id"; "required": false; }; "size": { "alias": "size"; "required": false; }; "imageSource": { "alias": "imageSource"; "required": false; }; "imageFallback": { "alias": "imageFallback"; "required": false; }; "imageAlt": { "alias": "imageAlt"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "hasAction": { "alias": "hasAction"; "required": false; }; "actionIconClass": { "alias": "actionIconClass"; "required": false; }; "isTile": { "alias": "isTile"; "required": false; }; "isBrand": { "alias": "isBrand"; "required": false; }; }, {}, never, ["*"], true, never>;

package/tree/lib/tree/components/tree-node-item/tree-node-item.component.d.ts

@@ -4,6 +4,7 @@ import * as i0 from "@angular/core";
 export declare class TreeNodeItemComponent {
     private readonly cdr;
     private readonly translateService;
+    private readonly elementRef;
     readonly ariaLevel: import("@angular/core").InputSignal<number>;
     readonly showCheckbox: import("@angular/core").InputSignal<boolean>;
     treeNodeItem: InternalTreeNodeItem;
@@ -20,6 +21,9 @@ export declare class TreeNodeItemComponent {
     get ariaLabel(): string;
     expandNode(): void;
     collapseNode(): void;
+    focusNextNode(event: Event): void;
+    focusPreviousNode(event: Event): void;
+    private moveFocus;
     onCheckboxEnter(node: InternalTreeNodeItem): void;
     handleTreeNodeItemClick(event: Event, treeNodeItem?: InternalTreeNodeItem): void;
     handleTreeNodeItemClicked({ event, item }: {