@juau/zuri 0.3.0 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -5
- package/fesm2022/juau-zuri.mjs +9614 -6433
- package/fesm2022/juau-zuri.mjs.map +1 -1
- package/package.json +1 -1
- package/types/juau-zuri.d.ts +931 -7
package/types/juau-zuri.d.ts
CHANGED
|
@@ -145,6 +145,27 @@ export interface ZurI18n {
|
|
|
145
145
|
/** Botão que alterna a densidade da interface. */
|
|
146
146
|
densityToCompact: string;
|
|
147
147
|
densityToComfortable: string;
|
|
148
|
+
/** Busca, edição no lugar e código. */
|
|
149
|
+
searchLabel: string;
|
|
150
|
+
copy: string;
|
|
151
|
+
copied: string;
|
|
152
|
+
copyFailed: string;
|
|
153
|
+
edit: string;
|
|
154
|
+
save: string;
|
|
155
|
+
inlineEditSaved: string;
|
|
156
|
+
inlineEditCancelled: string;
|
|
157
|
+
/** Texto para leitores de tela em links que abrem outra aba. */
|
|
158
|
+
opensInNewTab: string;
|
|
159
|
+
/** Seleção múltipla, tabela e navegação. */
|
|
160
|
+
optionAdded: (label: string) => string;
|
|
161
|
+
optionRemoved: (label: string) => string;
|
|
162
|
+
selectedCount: (count: number) => string;
|
|
163
|
+
clearSelection: string;
|
|
164
|
+
resizeColumn: (column: string) => string;
|
|
165
|
+
tableLoading: string;
|
|
166
|
+
bottomNav: string;
|
|
167
|
+
sheetHandle: string;
|
|
168
|
+
badgeCount: (count: number) => string;
|
|
148
169
|
}
|
|
149
170
|
export declare const ZUR_I18N_PT: ZurI18n;
|
|
150
171
|
export declare const ZUR_I18N_EN: ZurI18n;
|
|
@@ -214,6 +235,7 @@ export declare class ZurThemeToggle {
|
|
|
214
235
|
* ```
|
|
215
236
|
*/
|
|
216
237
|
export declare class ZurThemeScope {
|
|
238
|
+
constructor();
|
|
217
239
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurThemeScope, never>;
|
|
218
240
|
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurThemeScope, "[zurThemeScope]", never, {}, {}, never, never, true, never>;
|
|
219
241
|
}
|
|
@@ -423,6 +445,218 @@ export declare class ZurAvatarGroup {
|
|
|
423
445
|
};
|
|
424
446
|
}, {}, never, never, true, never>;
|
|
425
447
|
}
|
|
448
|
+
/**
|
|
449
|
+
* Conjunto de ícones do Zuri: traço de 2 px, pontas arredondadas, grade de 24 px.
|
|
450
|
+
* Cada ícone é uma constante exportada, então o bundler descarta os que o app não usa.
|
|
451
|
+
* Os marcados com `mirror` apontam para um lado e se espelham em RTL.
|
|
452
|
+
*
|
|
453
|
+
* ```html
|
|
454
|
+
* <zur-icon [icon]="lupa" /> // readonly lupa = zurIconSearch;
|
|
455
|
+
* ```
|
|
456
|
+
*/
|
|
457
|
+
export interface ZurIconDef {
|
|
458
|
+
/** Nome em kebab-case (para docs e testes). */
|
|
459
|
+
readonly name: string;
|
|
460
|
+
/** Dados do caminho SVG (`d`), em grade 24 × 24. */
|
|
461
|
+
readonly d: string;
|
|
462
|
+
/** Ícone direcional: espelha em páginas da direita para a esquerda. */
|
|
463
|
+
readonly mirror?: boolean;
|
|
464
|
+
}
|
|
465
|
+
export declare const zurIconCheck: ZurIconDef;
|
|
466
|
+
export declare const zurIconX: ZurIconDef;
|
|
467
|
+
export declare const zurIconPlus: ZurIconDef;
|
|
468
|
+
export declare const zurIconMinus: ZurIconDef;
|
|
469
|
+
export declare const zurIconChevronUp: ZurIconDef;
|
|
470
|
+
export declare const zurIconChevronDown: ZurIconDef;
|
|
471
|
+
export declare const zurIconChevronStart: ZurIconDef;
|
|
472
|
+
export declare const zurIconChevronEnd: ZurIconDef;
|
|
473
|
+
export declare const zurIconArrowUp: ZurIconDef;
|
|
474
|
+
export declare const zurIconArrowDown: ZurIconDef;
|
|
475
|
+
export declare const zurIconSearch: ZurIconDef;
|
|
476
|
+
export declare const zurIconMenu: ZurIconDef;
|
|
477
|
+
export declare const zurIconMoreHorizontal: ZurIconDef;
|
|
478
|
+
export declare const zurIconMoreVertical: ZurIconDef;
|
|
479
|
+
export declare const zurIconInfo: ZurIconDef;
|
|
480
|
+
export declare const zurIconAlertTriangle: ZurIconDef;
|
|
481
|
+
export declare const zurIconAlertCircle: ZurIconDef;
|
|
482
|
+
export declare const zurIconCheckCircle: ZurIconDef;
|
|
483
|
+
export declare const zurIconXCircle: ZurIconDef;
|
|
484
|
+
export declare const zurIconTrash: ZurIconDef;
|
|
485
|
+
export declare const zurIconPencil: ZurIconDef;
|
|
486
|
+
export declare const zurIconCopy: ZurIconDef;
|
|
487
|
+
export declare const zurIconDownload: ZurIconDef;
|
|
488
|
+
export declare const zurIconUpload: ZurIconDef;
|
|
489
|
+
export declare const zurIconLink: ZurIconDef;
|
|
490
|
+
export declare const zurIconExternalLink: ZurIconDef;
|
|
491
|
+
export declare const zurIconEye: ZurIconDef;
|
|
492
|
+
export declare const zurIconEyeOff: ZurIconDef;
|
|
493
|
+
export declare const zurIconCalendar: ZurIconDef;
|
|
494
|
+
export declare const zurIconClock: ZurIconDef;
|
|
495
|
+
export declare const zurIconUser: ZurIconDef;
|
|
496
|
+
export declare const zurIconUsers: ZurIconDef;
|
|
497
|
+
export declare const zurIconHome: ZurIconDef;
|
|
498
|
+
export declare const zurIconSettings: ZurIconDef;
|
|
499
|
+
export declare const zurIconHeart: ZurIconDef;
|
|
500
|
+
export declare const zurIconStar: ZurIconDef;
|
|
501
|
+
export declare const zurIconFilter: ZurIconDef;
|
|
502
|
+
export declare const zurIconSort: ZurIconDef;
|
|
503
|
+
export declare const zurIconRefresh: ZurIconDef;
|
|
504
|
+
export declare const zurIconBell: ZurIconDef;
|
|
505
|
+
export declare const zurIconMail: ZurIconDef;
|
|
506
|
+
export declare const zurIconImage: ZurIconDef;
|
|
507
|
+
export declare const zurIconFile: ZurIconDef;
|
|
508
|
+
export declare const zurIconFolder: ZurIconDef;
|
|
509
|
+
export declare const zurIconLock: ZurIconDef;
|
|
510
|
+
export declare const zurIconUndo: ZurIconDef;
|
|
511
|
+
export declare const zurIconGrip: ZurIconDef;
|
|
512
|
+
/** Todos os ícones, para catálogos e testes. Importar este objeto desativa o tree-shaking. */
|
|
513
|
+
export declare const ZUR_ICON_CATALOG: readonly ZurIconDef[];
|
|
514
|
+
/**
|
|
515
|
+
* Ícone SVG do Zuri. Sem `label` é decorativo (`aria-hidden`); com `label` vira `role="img"`.
|
|
516
|
+
* Os ícones direcionais (setas, chevrons) se espelham sozinhos em RTL.
|
|
517
|
+
*
|
|
518
|
+
* ```html
|
|
519
|
+
* <zur-icon [icon]="lupa" />
|
|
520
|
+
* <zur-icon [icon]="alerta" label="Atenção" [size]="24" />
|
|
521
|
+
* ```
|
|
522
|
+
*/
|
|
523
|
+
export declare class ZurIcon {
|
|
524
|
+
readonly icon: import("@angular/core").InputSignal<ZurIconDef>;
|
|
525
|
+
/** Lado em px (16, 20 ou 24 seguem a grade do sistema). */
|
|
526
|
+
readonly size: import("@angular/core").InputSignal<number>;
|
|
527
|
+
/** Texto acessível; sem ele o ícone é decorativo. */
|
|
528
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
529
|
+
protected readonly path: import("@angular/core").Signal<string>;
|
|
530
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurIcon, never>;
|
|
531
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurIcon, "zur-icon", never, {
|
|
532
|
+
"icon": {
|
|
533
|
+
"alias": "icon";
|
|
534
|
+
"required": true;
|
|
535
|
+
"isSignal": true;
|
|
536
|
+
};
|
|
537
|
+
"size": {
|
|
538
|
+
"alias": "size";
|
|
539
|
+
"required": false;
|
|
540
|
+
"isSignal": true;
|
|
541
|
+
};
|
|
542
|
+
"label": {
|
|
543
|
+
"alias": "label";
|
|
544
|
+
"required": false;
|
|
545
|
+
"isSignal": true;
|
|
546
|
+
};
|
|
547
|
+
}, {}, never, never, true, never>;
|
|
548
|
+
}
|
|
549
|
+
export type ZurIconButtonVariant = 'ghost' | 'secondary' | 'primary';
|
|
550
|
+
export type ZurIconButtonSize = 'sm' | 'md' | 'lg';
|
|
551
|
+
/**
|
|
552
|
+
* Botão quadrado só com ícone. O `label` é obrigatório: vira o `aria-label`, já que o botão
|
|
553
|
+
* não tem texto. O tamanho acompanha a densidade (`--zur-control-height-*`).
|
|
554
|
+
*
|
|
555
|
+
* ```html
|
|
556
|
+
* <button zur-icon-button label="Excluir"><zur-icon [icon]="lixeira" /></button>
|
|
557
|
+
* ```
|
|
558
|
+
*/
|
|
559
|
+
export declare class ZurIconButton {
|
|
560
|
+
/** Nome acessível do botão (obrigatório: não há texto visível). */
|
|
561
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
562
|
+
readonly variant: import("@angular/core").InputSignal<ZurIconButtonVariant>;
|
|
563
|
+
readonly size: import("@angular/core").InputSignal<ZurIconButtonSize>;
|
|
564
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurIconButton, never>;
|
|
565
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurIconButton, "button[zur-icon-button]", never, {
|
|
566
|
+
"label": {
|
|
567
|
+
"alias": "label";
|
|
568
|
+
"required": true;
|
|
569
|
+
"isSignal": true;
|
|
570
|
+
};
|
|
571
|
+
"variant": {
|
|
572
|
+
"alias": "variant";
|
|
573
|
+
"required": false;
|
|
574
|
+
"isSignal": true;
|
|
575
|
+
};
|
|
576
|
+
"size": {
|
|
577
|
+
"alias": "size";
|
|
578
|
+
"required": false;
|
|
579
|
+
"isSignal": true;
|
|
580
|
+
};
|
|
581
|
+
}, {}, never, ["*"], true, never>;
|
|
582
|
+
}
|
|
583
|
+
/**
|
|
584
|
+
* Botão de ação flutuante: o atalho para a ação principal da tela. É circular, menta
|
|
585
|
+
* e usa a sombra única do sistema. `extended` mostra o texto ao lado do ícone; sem ele,
|
|
586
|
+
* informe `label` para o leitor de tela. O posicionamento (fixo no canto) é da aplicação.
|
|
587
|
+
*
|
|
588
|
+
* ```html
|
|
589
|
+
* <button zur-fab label="Novo pedido"><zur-icon [icon]="mais" size="24" /></button>
|
|
590
|
+
* <button zur-fab extended><zur-icon [icon]="mais" /> Novo pedido</button>
|
|
591
|
+
* ```
|
|
592
|
+
*/
|
|
593
|
+
export declare class ZurFab {
|
|
594
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
595
|
+
readonly extended: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
596
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurFab, never>;
|
|
597
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurFab, "button[zur-fab]", never, {
|
|
598
|
+
"label": {
|
|
599
|
+
"alias": "label";
|
|
600
|
+
"required": false;
|
|
601
|
+
"isSignal": true;
|
|
602
|
+
};
|
|
603
|
+
"extended": {
|
|
604
|
+
"alias": "extended";
|
|
605
|
+
"required": false;
|
|
606
|
+
"isSignal": true;
|
|
607
|
+
};
|
|
608
|
+
}, {}, never, ["*"], true, never>;
|
|
609
|
+
}
|
|
610
|
+
/**
|
|
611
|
+
* Link com o estilo do sistema (ink sublinhado). Com `external`, abre em outra aba com
|
|
612
|
+
* `rel="noopener noreferrer"`, mostra o ícone e avisa os leitores de tela.
|
|
613
|
+
*
|
|
614
|
+
* ```html
|
|
615
|
+
* <a zur-link href="/entregas">Política de entrega</a>
|
|
616
|
+
* <a zur-link external href="https://exemplo.com">Guia de rega</a>
|
|
617
|
+
* ```
|
|
618
|
+
*/
|
|
619
|
+
export declare class ZurLink {
|
|
620
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
621
|
+
protected readonly iconExternal: import("@juau/zuri").ZurIconDef;
|
|
622
|
+
readonly external: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
623
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurLink, never>;
|
|
624
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurLink, "a[zur-link]", never, {
|
|
625
|
+
"external": {
|
|
626
|
+
"alias": "external";
|
|
627
|
+
"required": false;
|
|
628
|
+
"isSignal": true;
|
|
629
|
+
};
|
|
630
|
+
}, {}, never, ["*"], true, never>;
|
|
631
|
+
}
|
|
632
|
+
export type ZurDividerOrientation = 'horizontal' | 'vertical';
|
|
633
|
+
/**
|
|
634
|
+
* Linha fina que separa grupos de conteúdo. Com `label` mostra um texto no meio ("ou"),
|
|
635
|
+
* que também vira o nome acessível do separador.
|
|
636
|
+
*
|
|
637
|
+
* ```html
|
|
638
|
+
* <zur-divider />
|
|
639
|
+
* <zur-divider label="ou" />
|
|
640
|
+
* <zur-divider orientation="vertical" />
|
|
641
|
+
* ```
|
|
642
|
+
*/
|
|
643
|
+
export declare class ZurDivider {
|
|
644
|
+
readonly orientation: import("@angular/core").InputSignal<ZurDividerOrientation>;
|
|
645
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
646
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDivider, never>;
|
|
647
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurDivider, "zur-divider", never, {
|
|
648
|
+
"orientation": {
|
|
649
|
+
"alias": "orientation";
|
|
650
|
+
"required": false;
|
|
651
|
+
"isSignal": true;
|
|
652
|
+
};
|
|
653
|
+
"label": {
|
|
654
|
+
"alias": "label";
|
|
655
|
+
"required": false;
|
|
656
|
+
"isSignal": true;
|
|
657
|
+
};
|
|
658
|
+
}, {}, never, never, true, never>;
|
|
659
|
+
}
|
|
426
660
|
/**
|
|
427
661
|
* Campo de texto do Zuri — 56px, label em caption acima,
|
|
428
662
|
* foco com borda 2px ink (sem glow, Airbnb), erro em vermelho semântico.
|
|
@@ -690,8 +924,12 @@ export interface ZurComboboxOption {
|
|
|
690
924
|
* iniciais). Navegação por setas, Enter escolhe, Esc fecha. Funciona com
|
|
691
925
|
* `ngModel` e formulários reativos; o valor é o `value` da opção (ou `null`).
|
|
692
926
|
*
|
|
927
|
+
* Com `multiple`, vira seleção múltipla: as escolhas aparecem como chips dentro do campo, a lista
|
|
928
|
+
* continua aberta ao escolher e o valor é um `string[]`.
|
|
929
|
+
*
|
|
693
930
|
* ```html
|
|
694
931
|
* <zur-combobox label="Planta" [options]="plantas" [(ngModel)]="planta" />
|
|
932
|
+
* <zur-combobox label="Ambientes" multiple [options]="ambientes" [(ngModel)]="escolhidos" />
|
|
695
933
|
* ```
|
|
696
934
|
*/
|
|
697
935
|
export declare class ZurCombobox implements ControlValueAccessor {
|
|
@@ -703,32 +941,43 @@ export declare class ZurCombobox implements ControlValueAccessor {
|
|
|
703
941
|
readonly error: import("@angular/core").InputSignal<string>;
|
|
704
942
|
readonly options: import("@angular/core").InputSignal<ZurComboboxOption[]>;
|
|
705
943
|
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
944
|
+
/** Seleção múltipla: chips no campo, lista aberta ao escolher, valor `string[]`. */
|
|
945
|
+
readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
706
946
|
protected readonly id: string;
|
|
707
947
|
protected readonly listId: string;
|
|
708
948
|
readonly value: import("@angular/core").WritableSignal<string | null>;
|
|
949
|
+
/** Valores escolhidos no modo `multiple`. */
|
|
950
|
+
readonly values: import("@angular/core").WritableSignal<string[]>;
|
|
951
|
+
protected readonly announcement: import("@angular/core").WritableSignal<string>;
|
|
709
952
|
/** Texto digitado; `null` quando o campo só mostra o rótulo escolhido. */
|
|
710
953
|
private readonly typed;
|
|
711
954
|
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
712
955
|
protected readonly activeIndex: import("@angular/core").WritableSignal<number>;
|
|
713
956
|
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
714
957
|
private readonly selectedLabel;
|
|
958
|
+
protected readonly selectedOptions: import("@angular/core").Signal<ZurComboboxOption[]>;
|
|
715
959
|
protected readonly query: import("@angular/core").Signal<string>;
|
|
716
960
|
/** Enquanto o usuário não digita, mostra todas as opções. */
|
|
717
961
|
protected readonly filtered: import("@angular/core").Signal<ZurComboboxOption[]>;
|
|
718
|
-
protected onChange: (value: string | null) => void;
|
|
962
|
+
protected onChange: (value: string | string[] | null) => void;
|
|
719
963
|
protected onTouched: () => void;
|
|
964
|
+
protected hasValue(): boolean;
|
|
965
|
+
protected isSelected(value: string): boolean;
|
|
720
966
|
protected optionId(i: number): string;
|
|
721
967
|
protected isDisabled(): boolean;
|
|
722
968
|
protected openList(): void;
|
|
723
969
|
protected onInput(event: Event): void;
|
|
724
970
|
protected onKeydown(event: KeyboardEvent): void;
|
|
725
971
|
select(option: ZurComboboxOption): void;
|
|
972
|
+
/** Marca ou desmarca uma opção no modo `multiple`; a lista continua aberta. */
|
|
973
|
+
toggle(option: ZurComboboxOption): void;
|
|
974
|
+
protected removeTag(value: string): void;
|
|
726
975
|
clear(): void;
|
|
727
976
|
/** Fecha a lista e restaura o texto para o rótulo escolhido. */
|
|
728
977
|
private closeList;
|
|
729
978
|
protected onFocusOut(event: FocusEvent): void;
|
|
730
|
-
writeValue(value: string | null): void;
|
|
731
|
-
registerOnChange(fn: (value: string | null) => void): void;
|
|
979
|
+
writeValue(value: string | string[] | null): void;
|
|
980
|
+
registerOnChange(fn: (value: string | string[] | null) => void): void;
|
|
732
981
|
registerOnTouched(fn: () => void): void;
|
|
733
982
|
setDisabledState(isDisabled: boolean): void;
|
|
734
983
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCombobox, never>;
|
|
@@ -763,6 +1012,11 @@ export declare class ZurCombobox implements ControlValueAccessor {
|
|
|
763
1012
|
"required": false;
|
|
764
1013
|
"isSignal": true;
|
|
765
1014
|
};
|
|
1015
|
+
"multiple": {
|
|
1016
|
+
"alias": "multiple";
|
|
1017
|
+
"required": false;
|
|
1018
|
+
"isSignal": true;
|
|
1019
|
+
};
|
|
766
1020
|
}, {}, never, never, true, never>;
|
|
767
1021
|
}
|
|
768
1022
|
export type ZurDatePickerMode = 'single' | 'range';
|
|
@@ -1049,6 +1303,272 @@ export declare class ZurChips implements ControlValueAccessor {
|
|
|
1049
1303
|
};
|
|
1050
1304
|
}, {}, never, never, true, never>;
|
|
1051
1305
|
}
|
|
1306
|
+
export type ZurChipVariant = 'assist' | 'filter' | 'choice';
|
|
1307
|
+
export type ZurChipGroupMode = 'single' | 'multiple';
|
|
1308
|
+
/**
|
|
1309
|
+
* Grupo de chips selecionáveis. `mode="single"` é um `radiogroup` (setas trocam a escolha, Tab sai do
|
|
1310
|
+
* grupo); `mode="multiple"` é um conjunto de botões de alternar (filtros). O valor é `string` ou
|
|
1311
|
+
* `string[]`, conforme o modo, e funciona com `ngModel`, formulários reativos, `[formField]` e
|
|
1312
|
+
* `[(value)]`.
|
|
1313
|
+
*
|
|
1314
|
+
* ```html
|
|
1315
|
+
* <zur-chip-group label="Ambiente" mode="single" [(ngModel)]="ambiente">
|
|
1316
|
+
* <zur-chip value="sala">Sala</zur-chip>
|
|
1317
|
+
* <zur-chip value="varanda">Varanda</zur-chip>
|
|
1318
|
+
* </zur-chip-group>
|
|
1319
|
+
* ```
|
|
1320
|
+
*
|
|
1321
|
+
* Não confundir com `zur-chips`, o campo em que a pessoa digita para criar tags.
|
|
1322
|
+
*/
|
|
1323
|
+
export declare class ZurChipGroup implements ControlValueAccessor {
|
|
1324
|
+
private readonly host;
|
|
1325
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1326
|
+
readonly mode: import("@angular/core").InputSignal<ZurChipGroupMode>;
|
|
1327
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1328
|
+
readonly value: import("@angular/core").ModelSignal<string | string[] | null>;
|
|
1329
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1330
|
+
protected onChange: (value: string | string[] | null) => void;
|
|
1331
|
+
protected onTouched: () => void;
|
|
1332
|
+
isDisabled(): boolean;
|
|
1333
|
+
isSelected(value: string): boolean;
|
|
1334
|
+
/** Escolhe (single) ou alterna (multiple) um valor. */
|
|
1335
|
+
toggle(value: string): void;
|
|
1336
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1337
|
+
writeValue(value: string | string[] | null): void;
|
|
1338
|
+
registerOnChange(fn: (value: string | string[] | null) => void): void;
|
|
1339
|
+
registerOnTouched(fn: () => void): void;
|
|
1340
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1341
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChipGroup, never>;
|
|
1342
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChipGroup, "zur-chip-group", never, {
|
|
1343
|
+
"label": {
|
|
1344
|
+
"alias": "label";
|
|
1345
|
+
"required": false;
|
|
1346
|
+
"isSignal": true;
|
|
1347
|
+
};
|
|
1348
|
+
"mode": {
|
|
1349
|
+
"alias": "mode";
|
|
1350
|
+
"required": false;
|
|
1351
|
+
"isSignal": true;
|
|
1352
|
+
};
|
|
1353
|
+
"disabled": {
|
|
1354
|
+
"alias": "disabled";
|
|
1355
|
+
"required": false;
|
|
1356
|
+
"isSignal": true;
|
|
1357
|
+
};
|
|
1358
|
+
"value": {
|
|
1359
|
+
"alias": "value";
|
|
1360
|
+
"required": false;
|
|
1361
|
+
"isSignal": true;
|
|
1362
|
+
};
|
|
1363
|
+
}, {
|
|
1364
|
+
"value": "valueChange";
|
|
1365
|
+
}, never, ["*"], true, never>;
|
|
1366
|
+
}
|
|
1367
|
+
/**
|
|
1368
|
+
* Chip interativo: `assist` (ação rápida, use `(click)`), `filter` (liga e desliga, `[(selected)]`) e
|
|
1369
|
+
* `choice` (dentro de um `zur-chip-group`, com `value`). O estado selecionado tem ✓ e borda de ink,
|
|
1370
|
+
* não só cor. Com `removable`, mostra um ✕ que emite `removed`.
|
|
1371
|
+
*
|
|
1372
|
+
* ```html
|
|
1373
|
+
* <zur-chip variant="filter" [(selected)]="soSol">Pleno sol</zur-chip>
|
|
1374
|
+
* <zur-chip removable label="Sala" (removed)="tirar('sala')">Sala</zur-chip>
|
|
1375
|
+
* ```
|
|
1376
|
+
*/
|
|
1377
|
+
export declare class ZurChip {
|
|
1378
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1379
|
+
protected readonly host: ElementRef<HTMLElement>;
|
|
1380
|
+
private readonly group;
|
|
1381
|
+
readonly variant: import("@angular/core").InputSignal<ZurChipVariant>;
|
|
1382
|
+
/** Valor do chip dentro de um `zur-chip-group` (obrigatório lá). */
|
|
1383
|
+
readonly value: import("@angular/core").InputSignal<string>;
|
|
1384
|
+
/** Nome para o botão de remover; sem ele usa o texto do chip. */
|
|
1385
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1386
|
+
readonly selected: import("@angular/core").ModelSignal<boolean>;
|
|
1387
|
+
readonly removable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1388
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1389
|
+
readonly removed: import("@angular/core").OutputEmitterRef<void>;
|
|
1390
|
+
protected selectable(): boolean;
|
|
1391
|
+
protected isDisabled(): boolean;
|
|
1392
|
+
protected isSelected(): boolean;
|
|
1393
|
+
protected role(): string | null;
|
|
1394
|
+
protected pressed(): boolean | null;
|
|
1395
|
+
/** Em grupo `single`, só a escolha atual (ou todos, se nada foi escolhido) recebe o Tab. */
|
|
1396
|
+
protected tabStop(): boolean;
|
|
1397
|
+
protected onClick(): void;
|
|
1398
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChip, never>;
|
|
1399
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChip, "zur-chip", never, {
|
|
1400
|
+
"variant": {
|
|
1401
|
+
"alias": "variant";
|
|
1402
|
+
"required": false;
|
|
1403
|
+
"isSignal": true;
|
|
1404
|
+
};
|
|
1405
|
+
"value": {
|
|
1406
|
+
"alias": "value";
|
|
1407
|
+
"required": false;
|
|
1408
|
+
"isSignal": true;
|
|
1409
|
+
};
|
|
1410
|
+
"label": {
|
|
1411
|
+
"alias": "label";
|
|
1412
|
+
"required": false;
|
|
1413
|
+
"isSignal": true;
|
|
1414
|
+
};
|
|
1415
|
+
"selected": {
|
|
1416
|
+
"alias": "selected";
|
|
1417
|
+
"required": false;
|
|
1418
|
+
"isSignal": true;
|
|
1419
|
+
};
|
|
1420
|
+
"removable": {
|
|
1421
|
+
"alias": "removable";
|
|
1422
|
+
"required": false;
|
|
1423
|
+
"isSignal": true;
|
|
1424
|
+
};
|
|
1425
|
+
"disabled": {
|
|
1426
|
+
"alias": "disabled";
|
|
1427
|
+
"required": false;
|
|
1428
|
+
"isSignal": true;
|
|
1429
|
+
};
|
|
1430
|
+
}, {
|
|
1431
|
+
"selected": "selectedChange";
|
|
1432
|
+
"removed": "removed";
|
|
1433
|
+
}, never, ["*"], true, never>;
|
|
1434
|
+
}
|
|
1435
|
+
/**
|
|
1436
|
+
* Campo de busca: ícone de lupa, botão de limpar, Esc limpa e Enter envia. `searchChange` emite
|
|
1437
|
+
* enquanto a pessoa digita (com `debounceMs`, espera ela parar) e `submitted` emite no Enter.
|
|
1438
|
+
*
|
|
1439
|
+
* ```html
|
|
1440
|
+
* <zur-search label="Buscar plantas" [debounceMs]="250" (searchChange)="filtrar($event)" />
|
|
1441
|
+
* ```
|
|
1442
|
+
*/
|
|
1443
|
+
export declare class ZurSearch implements ControlValueAccessor {
|
|
1444
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1445
|
+
private readonly destroyRef;
|
|
1446
|
+
private readonly host;
|
|
1447
|
+
/** Nome acessível; sem ele usa "Buscar". */
|
|
1448
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1449
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
1450
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1451
|
+
/** Espera (ms) depois da última tecla antes de emitir `searchChange`; `0` emite na hora. */
|
|
1452
|
+
readonly debounceMs: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1453
|
+
readonly searchChange: import("@angular/core").OutputEmitterRef<string>;
|
|
1454
|
+
readonly submitted: import("@angular/core").OutputEmitterRef<string>;
|
|
1455
|
+
protected readonly id: string;
|
|
1456
|
+
protected readonly iconSearch: import("@juau/zuri").ZurIconDef;
|
|
1457
|
+
protected readonly iconX: import("@juau/zuri").ZurIconDef;
|
|
1458
|
+
protected readonly value: import("@angular/core").WritableSignal<string>;
|
|
1459
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1460
|
+
private timer;
|
|
1461
|
+
protected onChange: (value: string) => void;
|
|
1462
|
+
protected onTouched: () => void;
|
|
1463
|
+
constructor();
|
|
1464
|
+
protected isDisabled(): boolean;
|
|
1465
|
+
protected onInput(event: Event): void;
|
|
1466
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1467
|
+
clear(): void;
|
|
1468
|
+
writeValue(value: string | null): void;
|
|
1469
|
+
registerOnChange(fn: (value: string) => void): void;
|
|
1470
|
+
registerOnTouched(fn: () => void): void;
|
|
1471
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1472
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSearch, never>;
|
|
1473
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSearch, "zur-search", never, {
|
|
1474
|
+
"label": {
|
|
1475
|
+
"alias": "label";
|
|
1476
|
+
"required": false;
|
|
1477
|
+
"isSignal": true;
|
|
1478
|
+
};
|
|
1479
|
+
"placeholder": {
|
|
1480
|
+
"alias": "placeholder";
|
|
1481
|
+
"required": false;
|
|
1482
|
+
"isSignal": true;
|
|
1483
|
+
};
|
|
1484
|
+
"disabled": {
|
|
1485
|
+
"alias": "disabled";
|
|
1486
|
+
"required": false;
|
|
1487
|
+
"isSignal": true;
|
|
1488
|
+
};
|
|
1489
|
+
"debounceMs": {
|
|
1490
|
+
"alias": "debounceMs";
|
|
1491
|
+
"required": false;
|
|
1492
|
+
"isSignal": true;
|
|
1493
|
+
};
|
|
1494
|
+
}, {
|
|
1495
|
+
"searchChange": "searchChange";
|
|
1496
|
+
"submitted": "submitted";
|
|
1497
|
+
}, never, never, true, never>;
|
|
1498
|
+
}
|
|
1499
|
+
/**
|
|
1500
|
+
* Texto editável no lugar. Em leitura é um botão com o valor; clique, Enter ou F2 abrem o campo.
|
|
1501
|
+
* Enter salva (em `multiline`, Ctrl/⌘+Enter), Esc cancela e sair do campo salva. O foco volta ao
|
|
1502
|
+
* botão e um aviso (`aria-live`) diz o que aconteceu.
|
|
1503
|
+
*
|
|
1504
|
+
* ```html
|
|
1505
|
+
* <zur-inline-edit label="Nome do pedido" [(ngModel)]="nome" (saved)="persistir($event)" />
|
|
1506
|
+
* ```
|
|
1507
|
+
*/
|
|
1508
|
+
export declare class ZurInlineEdit implements ControlValueAccessor {
|
|
1509
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1510
|
+
private readonly host;
|
|
1511
|
+
private readonly injector;
|
|
1512
|
+
/** Nome acessível do campo (o que está sendo editado). */
|
|
1513
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1514
|
+
/** Texto mostrado, em muted, quando o valor está vazio. */
|
|
1515
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
1516
|
+
readonly multiline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1517
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1518
|
+
/** Emite o novo valor quando a edição é salva (e só se mudou). */
|
|
1519
|
+
readonly saved: import("@angular/core").OutputEmitterRef<string>;
|
|
1520
|
+
protected readonly iconCheck: import("@juau/zuri").ZurIconDef;
|
|
1521
|
+
protected readonly iconX: import("@juau/zuri").ZurIconDef;
|
|
1522
|
+
protected readonly iconPencil: import("@juau/zuri").ZurIconDef;
|
|
1523
|
+
readonly value: import("@angular/core").WritableSignal<string>;
|
|
1524
|
+
protected readonly editing: import("@angular/core").WritableSignal<boolean>;
|
|
1525
|
+
protected readonly draft: import("@angular/core").WritableSignal<string>;
|
|
1526
|
+
protected readonly announcement: import("@angular/core").WritableSignal<string>;
|
|
1527
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1528
|
+
protected onChange: (value: string) => void;
|
|
1529
|
+
protected onTouched: () => void;
|
|
1530
|
+
protected isDisabled(): boolean;
|
|
1531
|
+
start(): void;
|
|
1532
|
+
commit(): void;
|
|
1533
|
+
cancel(): void;
|
|
1534
|
+
private finish;
|
|
1535
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1536
|
+
protected onReadKeydown(event: KeyboardEvent): void;
|
|
1537
|
+
/**
|
|
1538
|
+
* Sair do campo (para fora do componente) salva. Só conta o `focusout` que vem do editor: ao
|
|
1539
|
+
* abrir, o botão de leitura que tinha o foco sai do DOM e o navegador também emite `focusout`.
|
|
1540
|
+
*/
|
|
1541
|
+
protected onFocusOut(event: FocusEvent): void;
|
|
1542
|
+
writeValue(value: string | null): void;
|
|
1543
|
+
registerOnChange(fn: (value: string) => void): void;
|
|
1544
|
+
registerOnTouched(fn: () => void): void;
|
|
1545
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1546
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurInlineEdit, never>;
|
|
1547
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurInlineEdit, "zur-inline-edit", never, {
|
|
1548
|
+
"label": {
|
|
1549
|
+
"alias": "label";
|
|
1550
|
+
"required": false;
|
|
1551
|
+
"isSignal": true;
|
|
1552
|
+
};
|
|
1553
|
+
"placeholder": {
|
|
1554
|
+
"alias": "placeholder";
|
|
1555
|
+
"required": false;
|
|
1556
|
+
"isSignal": true;
|
|
1557
|
+
};
|
|
1558
|
+
"multiline": {
|
|
1559
|
+
"alias": "multiline";
|
|
1560
|
+
"required": false;
|
|
1561
|
+
"isSignal": true;
|
|
1562
|
+
};
|
|
1563
|
+
"disabled": {
|
|
1564
|
+
"alias": "disabled";
|
|
1565
|
+
"required": false;
|
|
1566
|
+
"isSignal": true;
|
|
1567
|
+
};
|
|
1568
|
+
}, {
|
|
1569
|
+
"saved": "saved";
|
|
1570
|
+
}, never, never, true, never>;
|
|
1571
|
+
}
|
|
1052
1572
|
/**
|
|
1053
1573
|
* Controle deslizante. Com `range`, tem dois controles e o valor é `[mínimo, máximo]`;
|
|
1054
1574
|
* sem, é um número. Teclado: setas (±step), PageUp/PageDown (±10 steps), Home/End.
|
|
@@ -1595,6 +2115,72 @@ export declare class ZurTabs {
|
|
|
1595
2115
|
"index": "indexChange";
|
|
1596
2116
|
}, ["tabs"], ["*"], true, never>;
|
|
1597
2117
|
}
|
|
2118
|
+
/**
|
|
2119
|
+
* Barra de navegação inferior para celular: de 3 a 5 destinos principais, cada um com ícone e
|
|
2120
|
+
* rótulo. Respeita a área segura do aparelho (`safe-area-inset-bottom`). Por padrão fica fixa na
|
|
2121
|
+
* base da tela e some a partir de 768 px, onde a sidebar ou a navbar assumem.
|
|
2122
|
+
*
|
|
2123
|
+
* ```html
|
|
2124
|
+
* <zur-bottom-nav label="Navegação principal">
|
|
2125
|
+
* <a zur-bottom-nav-item href="/" active>
|
|
2126
|
+
* <zur-icon zurBottomNavIcon [icon]="casa" /> Início
|
|
2127
|
+
* </a>
|
|
2128
|
+
* <a zur-bottom-nav-item href="/pedidos" [badge]="3">
|
|
2129
|
+
* <zur-icon zurBottomNavIcon [icon]="sino" /> Pedidos
|
|
2130
|
+
* </a>
|
|
2131
|
+
* </zur-bottom-nav>
|
|
2132
|
+
* ```
|
|
2133
|
+
*/
|
|
2134
|
+
export declare class ZurBottomNav {
|
|
2135
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2136
|
+
/** Nome acessível da região; sem ele usa "Navegação inferior". */
|
|
2137
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2138
|
+
/** Fixa na base da tela. Desligue para posicionar você mesmo. */
|
|
2139
|
+
readonly fixed: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2140
|
+
/** Esconde a barra a partir de 768 px. Desligue para mostrá-la em qualquer largura. */
|
|
2141
|
+
readonly responsive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2142
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurBottomNav, never>;
|
|
2143
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurBottomNav, "zur-bottom-nav", never, {
|
|
2144
|
+
"label": {
|
|
2145
|
+
"alias": "label";
|
|
2146
|
+
"required": false;
|
|
2147
|
+
"isSignal": true;
|
|
2148
|
+
};
|
|
2149
|
+
"fixed": {
|
|
2150
|
+
"alias": "fixed";
|
|
2151
|
+
"required": false;
|
|
2152
|
+
"isSignal": true;
|
|
2153
|
+
};
|
|
2154
|
+
"responsive": {
|
|
2155
|
+
"alias": "responsive";
|
|
2156
|
+
"required": false;
|
|
2157
|
+
"isSignal": true;
|
|
2158
|
+
};
|
|
2159
|
+
}, {}, never, ["*"], true, never>;
|
|
2160
|
+
}
|
|
2161
|
+
/**
|
|
2162
|
+
* Destino da barra inferior: um `<a>` ou `<button>`. `active` marca a página atual
|
|
2163
|
+
* (`aria-current="page"`) e `badge` mostra um número, ou um ponto com `"dot"`.
|
|
2164
|
+
*/
|
|
2165
|
+
export declare class ZurBottomNavItem {
|
|
2166
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2167
|
+
readonly active: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2168
|
+
/** Número de novidades, ou `"dot"` para só um ponto. */
|
|
2169
|
+
readonly badge: import("@angular/core").InputSignal<number | "dot" | null>;
|
|
2170
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurBottomNavItem, never>;
|
|
2171
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurBottomNavItem, "a[zur-bottom-nav-item], button[zur-bottom-nav-item]", never, {
|
|
2172
|
+
"active": {
|
|
2173
|
+
"alias": "active";
|
|
2174
|
+
"required": false;
|
|
2175
|
+
"isSignal": true;
|
|
2176
|
+
};
|
|
2177
|
+
"badge": {
|
|
2178
|
+
"alias": "badge";
|
|
2179
|
+
"required": false;
|
|
2180
|
+
"isSignal": true;
|
|
2181
|
+
};
|
|
2182
|
+
}, {}, never, ["[zurBottomNavIcon]", "*"], true, never>;
|
|
2183
|
+
}
|
|
1598
2184
|
/** Item clicável dentro de <zur-menu>. */
|
|
1599
2185
|
export declare class ZurMenuItem {
|
|
1600
2186
|
readonly selected: import("@angular/core").OutputEmitterRef<void>;
|
|
@@ -1691,6 +2277,11 @@ export interface ZurColumnFilterChange {
|
|
|
1691
2277
|
key: string;
|
|
1692
2278
|
value: string;
|
|
1693
2279
|
}
|
|
2280
|
+
/** Largura nova de uma coluna redimensionada. */
|
|
2281
|
+
export interface ZurColumnResize {
|
|
2282
|
+
key: string;
|
|
2283
|
+
width: number;
|
|
2284
|
+
}
|
|
1694
2285
|
/**
|
|
1695
2286
|
* Estilo do Zuri para uma `<table>` nativa: cabeçalho em caption, linhas com
|
|
1696
2287
|
* hairline, hover e densidade. A ordenação fica com você: marque as colunas com
|
|
@@ -1711,6 +2302,16 @@ export declare class ZurTable {
|
|
|
1711
2302
|
/** Emite a coluna e a direção sempre que o usuário ordena. */
|
|
1712
2303
|
readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
|
|
1713
2304
|
readonly sort: import("@angular/core").WritableSignal<ZurSort | null>;
|
|
2305
|
+
/** Mantém o cabeçalho visível ao rolar (a tabela vai dentro de `.zur-table-scroll`). */
|
|
2306
|
+
readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2307
|
+
/** Mantém a primeira coluna visível na rolagem horizontal. */
|
|
2308
|
+
readonly stickyFirstColumn: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2309
|
+
/** Emite a nova largura (px) quando uma coluna `zurResizable` é redimensionada. */
|
|
2310
|
+
readonly columnResize: import("@angular/core").OutputEmitterRef<ZurColumnResize>;
|
|
2311
|
+
/** `true` enquanto há um `tbody[zurTableSkeleton]` na tabela (marca `aria-busy`). */
|
|
2312
|
+
readonly busy: import("@angular/core").WritableSignal<boolean>;
|
|
2313
|
+
/** Quantidade de colunas redimensionáveis (liga `table-layout: fixed`). */
|
|
2314
|
+
readonly resizableCount: import("@angular/core").WritableSignal<number>;
|
|
1714
2315
|
/** Ids das linhas selecionadas (two-way). Veja `tr[zurRow]`, `th[zurSelectAll]` e `td[zurSelect]`. */
|
|
1715
2316
|
readonly selected: import("@angular/core").ModelSignal<string[]>;
|
|
1716
2317
|
/** Emite quando o texto de filtro de uma coluna muda (`zur-column-filter`). */
|
|
@@ -1736,6 +2337,16 @@ export declare class ZurTable {
|
|
|
1736
2337
|
"required": false;
|
|
1737
2338
|
"isSignal": true;
|
|
1738
2339
|
};
|
|
2340
|
+
"stickyHeader": {
|
|
2341
|
+
"alias": "stickyHeader";
|
|
2342
|
+
"required": false;
|
|
2343
|
+
"isSignal": true;
|
|
2344
|
+
};
|
|
2345
|
+
"stickyFirstColumn": {
|
|
2346
|
+
"alias": "stickyFirstColumn";
|
|
2347
|
+
"required": false;
|
|
2348
|
+
"isSignal": true;
|
|
2349
|
+
};
|
|
1739
2350
|
"selected": {
|
|
1740
2351
|
"alias": "selected";
|
|
1741
2352
|
"required": false;
|
|
@@ -1743,6 +2354,7 @@ export declare class ZurTable {
|
|
|
1743
2354
|
};
|
|
1744
2355
|
}, {
|
|
1745
2356
|
"sortChange": "sortChange";
|
|
2357
|
+
"columnResize": "columnResize";
|
|
1746
2358
|
"selected": "selectedChange";
|
|
1747
2359
|
"filterChange": "filterChange";
|
|
1748
2360
|
}, never, ["*"], true, never>;
|
|
@@ -1904,6 +2516,109 @@ export declare class ZurColumnMenu {
|
|
|
1904
2516
|
"visible": "visibleChange";
|
|
1905
2517
|
}, never, never, true, never>;
|
|
1906
2518
|
}
|
|
2519
|
+
/**
|
|
2520
|
+
* Torna a coluna redimensionável: uma alça no fim da célula do cabeçalho arrasta com o mouse ou o
|
|
2521
|
+
* toque e também funciona pelo teclado (←/→ mudam 8 px, com Shift 32 px). O valor é a chave da
|
|
2522
|
+
* coluna; a largura nova sai em `columnResize` da tabela. Convive com `zurSortable`.
|
|
2523
|
+
*
|
|
2524
|
+
* ```html
|
|
2525
|
+
* <th zurSortable="nome" zurResizable="nome">Nome</th>
|
|
2526
|
+
* ```
|
|
2527
|
+
*/
|
|
2528
|
+
export declare class ZurResizable {
|
|
2529
|
+
private readonly table;
|
|
2530
|
+
private readonly i18n;
|
|
2531
|
+
private readonly el;
|
|
2532
|
+
private readonly renderer;
|
|
2533
|
+
private readonly injector;
|
|
2534
|
+
readonly zurResizable: import("@angular/core").InputSignal<string>;
|
|
2535
|
+
readonly minWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2536
|
+
readonly maxWidth: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2537
|
+
private handle;
|
|
2538
|
+
constructor();
|
|
2539
|
+
private clamp;
|
|
2540
|
+
private apply;
|
|
2541
|
+
private createHandle;
|
|
2542
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurResizable, never>;
|
|
2543
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurResizable, "th[zurResizable]", never, {
|
|
2544
|
+
"zurResizable": {
|
|
2545
|
+
"alias": "zurResizable";
|
|
2546
|
+
"required": true;
|
|
2547
|
+
"isSignal": true;
|
|
2548
|
+
};
|
|
2549
|
+
"minWidth": {
|
|
2550
|
+
"alias": "minWidth";
|
|
2551
|
+
"required": false;
|
|
2552
|
+
"isSignal": true;
|
|
2553
|
+
};
|
|
2554
|
+
"maxWidth": {
|
|
2555
|
+
"alias": "maxWidth";
|
|
2556
|
+
"required": false;
|
|
2557
|
+
"isSignal": true;
|
|
2558
|
+
};
|
|
2559
|
+
}, {}, never, never, true, never>;
|
|
2560
|
+
}
|
|
2561
|
+
/**
|
|
2562
|
+
* Barra acima da tabela. Em repouso mostra o que você projetar (busca, filtros, botão de
|
|
2563
|
+
* exportar); com linhas selecionadas (`[selectedCount]`) troca para a barra de lote: contagem, as
|
|
2564
|
+
* ações de `[zurTableToolbarBatch]` e "Limpar seleção". A contagem é anunciada para leitores de tela.
|
|
2565
|
+
*
|
|
2566
|
+
* ```html
|
|
2567
|
+
* <zur-table-toolbar [selectedCount]="marcadas().length" (clearSelection)="marcadas.set([])">
|
|
2568
|
+
* <zur-search label="Buscar pedidos" />
|
|
2569
|
+
* <button zurTableToolbarBatch zur-button size="sm" variant="danger">Excluir</button>
|
|
2570
|
+
* </zur-table-toolbar>
|
|
2571
|
+
* ```
|
|
2572
|
+
*/
|
|
2573
|
+
export declare class ZurTableToolbar {
|
|
2574
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2575
|
+
/** Linhas selecionadas; maior que zero liga a barra de lote. */
|
|
2576
|
+
readonly selectedCount: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2577
|
+
readonly clearSelection: import("@angular/core").OutputEmitterRef<void>;
|
|
2578
|
+
protected readonly batch: import("@angular/core").Signal<boolean>;
|
|
2579
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTableToolbar, never>;
|
|
2580
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTableToolbar, "zur-table-toolbar", never, {
|
|
2581
|
+
"selectedCount": {
|
|
2582
|
+
"alias": "selectedCount";
|
|
2583
|
+
"required": false;
|
|
2584
|
+
"isSignal": true;
|
|
2585
|
+
};
|
|
2586
|
+
}, {
|
|
2587
|
+
"clearSelection": "clearSelection";
|
|
2588
|
+
}, never, ["[zurTableToolbarBatch]", "*"], true, never>;
|
|
2589
|
+
}
|
|
2590
|
+
/**
|
|
2591
|
+
* Corpo de carregamento: `rows` linhas de `columns` células em skeleton, e a tabela fica com
|
|
2592
|
+
* `aria-busy` e um aviso "Carregando dados" para leitores de tela. Troque pelo `tbody` real
|
|
2593
|
+
* quando os dados chegarem.
|
|
2594
|
+
*
|
|
2595
|
+
* ```html
|
|
2596
|
+
* @if (carregando()) { <tbody zurTableSkeleton [rows]="5" [columns]="4"></tbody> } @else { <tbody>…</tbody> }
|
|
2597
|
+
* ```
|
|
2598
|
+
*/
|
|
2599
|
+
export declare class ZurTableSkeleton {
|
|
2600
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2601
|
+
private readonly table;
|
|
2602
|
+
readonly rows: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2603
|
+
readonly columns: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2604
|
+
protected readonly widths: string[];
|
|
2605
|
+
protected readonly rowList: import("@angular/core").Signal<number[]>;
|
|
2606
|
+
protected readonly colList: import("@angular/core").Signal<number[]>;
|
|
2607
|
+
constructor();
|
|
2608
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTableSkeleton, never>;
|
|
2609
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTableSkeleton, "tbody[zurTableSkeleton]", never, {
|
|
2610
|
+
"rows": {
|
|
2611
|
+
"alias": "rows";
|
|
2612
|
+
"required": false;
|
|
2613
|
+
"isSignal": true;
|
|
2614
|
+
};
|
|
2615
|
+
"columns": {
|
|
2616
|
+
"alias": "columns";
|
|
2617
|
+
"required": false;
|
|
2618
|
+
"isSignal": true;
|
|
2619
|
+
};
|
|
2620
|
+
}, {}, never, never, true, never>;
|
|
2621
|
+
}
|
|
1907
2622
|
export type ZurChartType = 'bar' | 'line' | 'area' | 'donut';
|
|
1908
2623
|
export interface ZurChartSeries {
|
|
1909
2624
|
name: string;
|
|
@@ -2478,6 +3193,163 @@ export declare class ZurStep {
|
|
|
2478
3193
|
};
|
|
2479
3194
|
}, {}, never, ["*"], true, never>;
|
|
2480
3195
|
}
|
|
3196
|
+
/**
|
|
3197
|
+
* Bloco de código com botão de copiar. O texto é sempre da esquerda para a direita (também em RTL),
|
|
3198
|
+
* o botão anuncia "Copiado" ou "Não foi possível copiar" para leitores de tela e a área rola na
|
|
3199
|
+
* horizontal com o teclado.
|
|
3200
|
+
*
|
|
3201
|
+
* ```html
|
|
3202
|
+
* <zur-code-snippet language="bash" code="npm install @juau/zuri" />
|
|
3203
|
+
* ```
|
|
3204
|
+
*/
|
|
3205
|
+
export declare class ZurCodeSnippet {
|
|
3206
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3207
|
+
readonly code: import("@angular/core").InputSignal<string>;
|
|
3208
|
+
/** Rótulo da linguagem mostrado no topo ("bash", "html"…). */
|
|
3209
|
+
readonly language: import("@angular/core").InputSignal<string>;
|
|
3210
|
+
/** Nome acessível do bloco; sem ele usa a linguagem. */
|
|
3211
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
3212
|
+
protected readonly iconCopy: import("@juau/zuri").ZurIconDef;
|
|
3213
|
+
protected readonly iconCheck: import("@juau/zuri").ZurIconDef;
|
|
3214
|
+
protected readonly copied: import("@angular/core").WritableSignal<boolean>;
|
|
3215
|
+
protected readonly announcement: import("@angular/core").WritableSignal<string>;
|
|
3216
|
+
private timer;
|
|
3217
|
+
constructor();
|
|
3218
|
+
copy(): Promise<void>;
|
|
3219
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCodeSnippet, never>;
|
|
3220
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurCodeSnippet, "zur-code-snippet", never, {
|
|
3221
|
+
"code": {
|
|
3222
|
+
"alias": "code";
|
|
3223
|
+
"required": true;
|
|
3224
|
+
"isSignal": true;
|
|
3225
|
+
};
|
|
3226
|
+
"language": {
|
|
3227
|
+
"alias": "language";
|
|
3228
|
+
"required": false;
|
|
3229
|
+
"isSignal": true;
|
|
3230
|
+
};
|
|
3231
|
+
"label": {
|
|
3232
|
+
"alias": "label";
|
|
3233
|
+
"required": false;
|
|
3234
|
+
"isSignal": true;
|
|
3235
|
+
};
|
|
3236
|
+
}, {}, never, never, true, never>;
|
|
3237
|
+
}
|
|
3238
|
+
export type ZurListSelection = 'none' | 'single' | 'multiple';
|
|
3239
|
+
/**
|
|
3240
|
+
* Lista vertical de itens com área para ícone/avatar, texto principal, texto secundário e ação.
|
|
3241
|
+
* Com `selection="single" | "multiple"` vira um `listbox`: setas movem o foco, Espaço/Enter escolhem
|
|
3242
|
+
* e o valor (`string` ou `string[]`) funciona com `ngModel`, formulários reativos e `[formField]`.
|
|
3243
|
+
*
|
|
3244
|
+
* ```html
|
|
3245
|
+
* <zur-list label="Pedidos" selection="single" contained divided [(ngModel)]="pedido">
|
|
3246
|
+
* <zur-list-item value="42">
|
|
3247
|
+
* <zur-avatar zurListLeading name="Ana Silva" size="sm" />
|
|
3248
|
+
* Pedido 42
|
|
3249
|
+
* <span zurListSecondary>Monstera e vaso</span>
|
|
3250
|
+
* <zur-badge zurListTrailing>Enviado</zur-badge>
|
|
3251
|
+
* </zur-list-item>
|
|
3252
|
+
* </zur-list>
|
|
3253
|
+
* ```
|
|
3254
|
+
*/
|
|
3255
|
+
export declare class ZurList implements ControlValueAccessor {
|
|
3256
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
3257
|
+
readonly selection: import("@angular/core").InputSignal<ZurListSelection>;
|
|
3258
|
+
/** Borda e raio de 14 px em volta da lista. */
|
|
3259
|
+
readonly contained: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3260
|
+
/** Fio entre os itens. */
|
|
3261
|
+
readonly divided: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3262
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3263
|
+
readonly value: import("@angular/core").ModelSignal<string | string[] | null>;
|
|
3264
|
+
protected readonly items: import("@angular/core").Signal<readonly any[]>;
|
|
3265
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
3266
|
+
private readonly focused;
|
|
3267
|
+
protected onChange: (value: string | string[] | null) => void;
|
|
3268
|
+
protected onTouched: () => void;
|
|
3269
|
+
readonly selectable: import("@angular/core").Signal<boolean>;
|
|
3270
|
+
isDisabled(): boolean;
|
|
3271
|
+
isSelected(value: string): boolean;
|
|
3272
|
+
/** Valor do item que recebe o Tab: o último focado, o escolhido ou o primeiro habilitado. */
|
|
3273
|
+
readonly tabValue: import("@angular/core").Signal<any>;
|
|
3274
|
+
select(value: string): void;
|
|
3275
|
+
protected onFocusIn(event: FocusEvent): void;
|
|
3276
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3277
|
+
writeValue(value: string | string[] | null): void;
|
|
3278
|
+
registerOnChange(fn: (value: string | string[] | null) => void): void;
|
|
3279
|
+
registerOnTouched(fn: () => void): void;
|
|
3280
|
+
setDisabledState(isDisabled: boolean): void;
|
|
3281
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurList, never>;
|
|
3282
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurList, "zur-list", never, {
|
|
3283
|
+
"label": {
|
|
3284
|
+
"alias": "label";
|
|
3285
|
+
"required": false;
|
|
3286
|
+
"isSignal": true;
|
|
3287
|
+
};
|
|
3288
|
+
"selection": {
|
|
3289
|
+
"alias": "selection";
|
|
3290
|
+
"required": false;
|
|
3291
|
+
"isSignal": true;
|
|
3292
|
+
};
|
|
3293
|
+
"contained": {
|
|
3294
|
+
"alias": "contained";
|
|
3295
|
+
"required": false;
|
|
3296
|
+
"isSignal": true;
|
|
3297
|
+
};
|
|
3298
|
+
"divided": {
|
|
3299
|
+
"alias": "divided";
|
|
3300
|
+
"required": false;
|
|
3301
|
+
"isSignal": true;
|
|
3302
|
+
};
|
|
3303
|
+
"disabled": {
|
|
3304
|
+
"alias": "disabled";
|
|
3305
|
+
"required": false;
|
|
3306
|
+
"isSignal": true;
|
|
3307
|
+
};
|
|
3308
|
+
"value": {
|
|
3309
|
+
"alias": "value";
|
|
3310
|
+
"required": false;
|
|
3311
|
+
"isSignal": true;
|
|
3312
|
+
};
|
|
3313
|
+
}, {
|
|
3314
|
+
"value": "valueChange";
|
|
3315
|
+
}, ["items"], ["*"], true, never>;
|
|
3316
|
+
}
|
|
3317
|
+
/**
|
|
3318
|
+
* Item da lista. Slots: `[zurListLeading]` (ícone, avatar), o texto principal, `[zurListSecondary]`
|
|
3319
|
+
* e `[zurListTrailing]` (badge, botão). Com `interactive` (fora de uma lista selecionável) a linha
|
|
3320
|
+
* vira um botão e o `(click)` do item funciona.
|
|
3321
|
+
*/
|
|
3322
|
+
export declare class ZurListItem {
|
|
3323
|
+
readonly el: ElementRef<HTMLElement>;
|
|
3324
|
+
protected readonly list: ZurList | null;
|
|
3325
|
+
/** Identifica o item nas listas selecionáveis (obrigatório lá). */
|
|
3326
|
+
readonly value: import("@angular/core").InputSignal<string>;
|
|
3327
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3328
|
+
/** Linha clicável (botão), para listas que não são de seleção. */
|
|
3329
|
+
readonly interactive: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3330
|
+
isDisabled(): boolean;
|
|
3331
|
+
protected selected(): boolean;
|
|
3332
|
+
protected isTabStop(): boolean;
|
|
3333
|
+
protected onClick(): void;
|
|
3334
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurListItem, never>;
|
|
3335
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurListItem, "zur-list-item", never, {
|
|
3336
|
+
"value": {
|
|
3337
|
+
"alias": "value";
|
|
3338
|
+
"required": false;
|
|
3339
|
+
"isSignal": true;
|
|
3340
|
+
};
|
|
3341
|
+
"disabled": {
|
|
3342
|
+
"alias": "disabled";
|
|
3343
|
+
"required": false;
|
|
3344
|
+
"isSignal": true;
|
|
3345
|
+
};
|
|
3346
|
+
"interactive": {
|
|
3347
|
+
"alias": "interactive";
|
|
3348
|
+
"required": false;
|
|
3349
|
+
"isSignal": true;
|
|
3350
|
+
};
|
|
3351
|
+
}, {}, never, ["[zurListLeading]", "*", "[zurListSecondary]", "[zurListTrailing]"], true, never>;
|
|
3352
|
+
}
|
|
2481
3353
|
export type ZurStepperOrientation = 'horizontal' | 'vertical';
|
|
2482
3354
|
export type ZurStepStatus = 'done' | 'current' | 'upcoming' | 'error';
|
|
2483
3355
|
/** Conteúdo de uma etapa do `zur-stepper`; só a etapa atual é mostrada. */
|
|
@@ -2902,16 +3774,51 @@ export declare class ZurModal {
|
|
|
2902
3774
|
}, never, ["*", "[zurModalActions]"], true, never>;
|
|
2903
3775
|
}
|
|
2904
3776
|
export type ZurToastKind = 'neutral' | 'success' | 'error';
|
|
3777
|
+
export interface ZurToastAction {
|
|
3778
|
+
/** Texto do botão ("Desfazer"). */
|
|
3779
|
+
label: string;
|
|
3780
|
+
/** Roda ao clicar; o toast fecha em seguida. */
|
|
3781
|
+
handler: () => void;
|
|
3782
|
+
}
|
|
3783
|
+
export interface ZurToastOptions {
|
|
3784
|
+
/** Tempo na tela em ms. Padrão: 4000, ou 8000 quando há ação. */
|
|
3785
|
+
durationMs?: number;
|
|
3786
|
+
/** Botão de texto dentro do toast, para desfazer ou abrir algo. */
|
|
3787
|
+
action?: ZurToastAction;
|
|
3788
|
+
/** Não fecha sozinho: só pelo ✕, pela ação ou por `dismiss`. */
|
|
3789
|
+
persistent?: boolean;
|
|
3790
|
+
}
|
|
2905
3791
|
export interface ZurToast {
|
|
2906
3792
|
id: number;
|
|
2907
3793
|
message: string;
|
|
2908
3794
|
kind: ZurToastKind;
|
|
3795
|
+
action?: ZurToastAction;
|
|
3796
|
+
persistent: boolean;
|
|
2909
3797
|
}
|
|
2910
|
-
/**
|
|
3798
|
+
/**
|
|
3799
|
+
* Fila de toasts — use junto com <zur-toast-container>.
|
|
3800
|
+
*
|
|
3801
|
+
* O tempo de cada toast pausa enquanto o ponteiro ou o foco estão sobre a pilha (WCAG 2.2.1) e
|
|
3802
|
+
* continua de onde parou. `show` devolve o id, para fechar por `dismiss(id)`.
|
|
3803
|
+
*
|
|
3804
|
+
* ```ts
|
|
3805
|
+
* toast.show('Planta removida', 'neutral', { action: { label: 'Desfazer', handler: () => restaurar() } });
|
|
3806
|
+
* toast.show('Sem conexão', 'error', { persistent: true });
|
|
3807
|
+
* toast.show('Salvo', 'success', 2000); // forma curta: só a duração
|
|
3808
|
+
* ```
|
|
3809
|
+
*/
|
|
2911
3810
|
export declare class ZurToastService {
|
|
2912
3811
|
readonly toasts: import("@angular/core").WritableSignal<ZurToast[]>;
|
|
2913
|
-
|
|
3812
|
+
private readonly timers;
|
|
3813
|
+
private paused;
|
|
3814
|
+
show(message: string, kind?: ZurToastKind, options?: number | ZurToastOptions): number;
|
|
2914
3815
|
dismiss(id: number): void;
|
|
3816
|
+
dismissAll(): void;
|
|
3817
|
+
/** Congela o tempo de todos os toasts (o container chama com ponteiro ou foco sobre a pilha). */
|
|
3818
|
+
pauseAll(): void;
|
|
3819
|
+
/** Retoma o tempo que faltava de cada toast. */
|
|
3820
|
+
resumeAll(): void;
|
|
3821
|
+
private start;
|
|
2915
3822
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastService, never>;
|
|
2916
3823
|
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
2917
3824
|
}
|
|
@@ -2922,6 +3829,11 @@ export declare class ZurToastService {
|
|
|
2922
3829
|
export declare class ZurToastContainer {
|
|
2923
3830
|
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2924
3831
|
protected readonly service: ZurToastService;
|
|
3832
|
+
/** O tempo dos toasts pausa com o ponteiro ou o foco sobre a pilha. */
|
|
3833
|
+
protected hovering: boolean;
|
|
3834
|
+
protected focusWithin: boolean;
|
|
3835
|
+
protected sync(): void;
|
|
3836
|
+
protected onFocusOut(event: FocusEvent): void;
|
|
2925
3837
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurToastContainer, never>;
|
|
2926
3838
|
static ɵcmp: i0.ɵɵComponentDeclaration<ZurToastContainer, "zur-toast-container", never, {}, {}, never, never, true, never>;
|
|
2927
3839
|
}
|
|
@@ -3084,8 +3996,11 @@ export declare class ZurProgress {
|
|
|
3084
3996
|
};
|
|
3085
3997
|
}, {}, never, never, true, never>;
|
|
3086
3998
|
}
|
|
3087
|
-
/**
|
|
3088
|
-
|
|
3999
|
+
/**
|
|
4000
|
+
* `start`/`end` seguem a direção de leitura (em RTL trocam de lado); `left`/`right` são físicos.
|
|
4001
|
+
* `bottom` é o bottom sheet: sobe da borda inferior, tem alça e fecha arrastando para baixo.
|
|
4002
|
+
*/
|
|
4003
|
+
export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right' | 'bottom';
|
|
3089
4004
|
/**
|
|
3090
4005
|
* Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
|
|
3091
4006
|
* formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
|
|
@@ -3094,6 +4009,7 @@ export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right';
|
|
|
3094
4009
|
* ```html
|
|
3095
4010
|
* <button zur-button (click)="filtros = true">Filtros</button>
|
|
3096
4011
|
* <zur-drawer [(open)]="filtros" title="Filtros">…</zur-drawer>
|
|
4012
|
+
* <zur-drawer [(open)]="opcoes" side="bottom" title="Opções">…</zur-drawer> // bottom sheet
|
|
3097
4013
|
* ```
|
|
3098
4014
|
*/
|
|
3099
4015
|
export declare class ZurDrawer {
|
|
@@ -3103,9 +4019,17 @@ export declare class ZurDrawer {
|
|
|
3103
4019
|
readonly title: import("@angular/core").InputSignal<string>;
|
|
3104
4020
|
readonly side: import("@angular/core").InputSignal<ZurDrawerSide>;
|
|
3105
4021
|
private readonly panel;
|
|
4022
|
+
/** Deslocamento (px) do bottom sheet enquanto é arrastado para baixo. */
|
|
4023
|
+
protected readonly dragY: import("@angular/core").WritableSignal<number>;
|
|
4024
|
+
protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
|
|
4025
|
+
private dragStartY;
|
|
3106
4026
|
private returnFocusTo;
|
|
3107
4027
|
constructor();
|
|
3108
4028
|
close(): void;
|
|
4029
|
+
protected dragStart(event: PointerEvent): void;
|
|
4030
|
+
protected dragMove(event: PointerEvent): void;
|
|
4031
|
+
/** Solta: fecha se foi arrastado além de 100 px (ou 30% da altura); senão volta ao lugar. */
|
|
4032
|
+
protected dragEnd(event: PointerEvent): void;
|
|
3109
4033
|
/** Mantém o Tab circulando dentro do painel. */
|
|
3110
4034
|
protected trapFocus(event: KeyboardEvent): void;
|
|
3111
4035
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDrawer, never>;
|