@juau/zuri 0.1.0 → 0.3.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 +63 -12
- package/fesm2022/juau-zuri.mjs +12027 -2094
- package/fesm2022/juau-zuri.mjs.map +1 -1
- package/package.json +4 -1
- package/styles/tokens.css +52 -0
- package/tailwind-theme.css +61 -0
- package/tailwind.preset.cjs +83 -0
- package/tokens.json +820 -0
- package/types/juau-zuri.d.ts +2526 -128
package/types/juau-zuri.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import * as i0 from "@angular/core";
|
|
2
|
-
import { ElementRef, InjectionToken, OnDestroy, OnInit, Provider } from "@angular/core";
|
|
2
|
+
import { ElementRef, InjectionToken, OnDestroy, OnInit, Provider, TemplateRef } from "@angular/core";
|
|
3
3
|
import { ControlValueAccessor } from "@angular/forms";
|
|
4
4
|
/**
|
|
5
5
|
* Textos que os componentes do Zuri mostram ou anunciam para leitores de tela
|
|
@@ -7,6 +7,8 @@ import { ControlValueAccessor } from "@angular/forms";
|
|
|
7
7
|
* troque com `provideZuriI18n('en')` ou passe só as chaves que quiser mudar.
|
|
8
8
|
*/
|
|
9
9
|
export interface ZurI18n {
|
|
10
|
+
/** Locale BCP 47 usado para formatar datas e nomes de mês/dia (date picker). */
|
|
11
|
+
locale: string;
|
|
10
12
|
/** Botão de fechar (modal, toast, drawer). */
|
|
11
13
|
close: string;
|
|
12
14
|
/** Botão de voltar (lista e detalhe no mobile). */
|
|
@@ -41,6 +43,108 @@ export interface ZurI18n {
|
|
|
41
43
|
progress: string;
|
|
42
44
|
/** Contador de caracteres do textarea, ex.: "12 de 200 caracteres". */
|
|
43
45
|
characterCount: (count: number, max: number) => string;
|
|
46
|
+
/** Combobox e paleta de comandos sem resultado. */
|
|
47
|
+
noResults: string;
|
|
48
|
+
/** Botão que limpa o valor (combobox, chips). */
|
|
49
|
+
clear: string;
|
|
50
|
+
/** Botão que abre o calendário. */
|
|
51
|
+
openCalendar: string;
|
|
52
|
+
previousMonth: string;
|
|
53
|
+
nextMonth: string;
|
|
54
|
+
/** Data selecionada na faixa: início/fim. */
|
|
55
|
+
rangeStart: string;
|
|
56
|
+
rangeEnd: string;
|
|
57
|
+
/** Upload: texto da área de soltar e do botão. */
|
|
58
|
+
dropFiles: string;
|
|
59
|
+
browseFiles: string;
|
|
60
|
+
removeFile: (name: string) => string;
|
|
61
|
+
fileTooLarge: (name: string, maxSize: string) => string;
|
|
62
|
+
fileTypeNotAllowed: (name: string) => string;
|
|
63
|
+
/** Chips. */
|
|
64
|
+
removeChip: (label: string) => string;
|
|
65
|
+
/** Slider de faixa: rótulos dos dois controles. */
|
|
66
|
+
minimum: string;
|
|
67
|
+
maximum: string;
|
|
68
|
+
/** Chat. */
|
|
69
|
+
chatLog: string;
|
|
70
|
+
messagePlaceholder: string;
|
|
71
|
+
sendMessage: string;
|
|
72
|
+
attachFile: string;
|
|
73
|
+
typing: (name: string) => string;
|
|
74
|
+
/** Paleta de comandos. */
|
|
75
|
+
commandPalette: string;
|
|
76
|
+
commandPlaceholder: string;
|
|
77
|
+
/** Central de notificações. */
|
|
78
|
+
notifications: string;
|
|
79
|
+
unreadNotifications: (count: number) => string;
|
|
80
|
+
markAllRead: string;
|
|
81
|
+
noNotifications: string;
|
|
82
|
+
today: string;
|
|
83
|
+
earlier: string;
|
|
84
|
+
/** Kanban (anúncios do arrasto por teclado). */
|
|
85
|
+
kanbanInstructions: string;
|
|
86
|
+
cardGrabbed: (card: string, column: string, position: number) => string;
|
|
87
|
+
cardMoved: (card: string, column: string, position: number) => string;
|
|
88
|
+
cardDropped: (card: string, column: string, position: number) => string;
|
|
89
|
+
cardCancelled: (card: string) => string;
|
|
90
|
+
/** Campo numérico. */
|
|
91
|
+
increase: string;
|
|
92
|
+
decrease: string;
|
|
93
|
+
/** Código de verificação (OTP). */
|
|
94
|
+
otpGroup: string;
|
|
95
|
+
otpDigit: (n: number, total: number) => string;
|
|
96
|
+
/** Avaliação por estrelas. */
|
|
97
|
+
ratingValue: (value: number, max: number) => string;
|
|
98
|
+
ratingStar: (n: number) => string;
|
|
99
|
+
/** Seletor de horário. */
|
|
100
|
+
openTimePicker: string;
|
|
101
|
+
hours: string;
|
|
102
|
+
minutes: string;
|
|
103
|
+
/** Stepper. */
|
|
104
|
+
stepOf: (n: number, total: number) => string;
|
|
105
|
+
stepDone: string;
|
|
106
|
+
stepCurrent: string;
|
|
107
|
+
stepError: string;
|
|
108
|
+
/** Carrossel. */
|
|
109
|
+
carousel: string;
|
|
110
|
+
previousSlide: string;
|
|
111
|
+
nextSlide: string;
|
|
112
|
+
slideOf: (n: number, total: number) => string;
|
|
113
|
+
goToSlide: (n: number) => string;
|
|
114
|
+
pauseCarousel: string;
|
|
115
|
+
playCarousel: string;
|
|
116
|
+
/** Grupo de avatares: "+3". */
|
|
117
|
+
moreAvatars: (count: number) => string;
|
|
118
|
+
/** Diálogo de confirmação. */
|
|
119
|
+
confirm: string;
|
|
120
|
+
cancel: string;
|
|
121
|
+
ok: string;
|
|
122
|
+
/** Menu de contexto. */
|
|
123
|
+
contextMenu: string;
|
|
124
|
+
/** Linha do tempo e árvore. */
|
|
125
|
+
timeline: string;
|
|
126
|
+
tree: string;
|
|
127
|
+
expandNode: (label: string) => string;
|
|
128
|
+
collapseNode: (label: string) => string;
|
|
129
|
+
/** Tabela avançada. */
|
|
130
|
+
selectAllRows: string;
|
|
131
|
+
selectRow: string;
|
|
132
|
+
expandRow: string;
|
|
133
|
+
collapseRow: string;
|
|
134
|
+
filterColumn: (column: string) => string;
|
|
135
|
+
clearFilter: string;
|
|
136
|
+
visibleColumns: string;
|
|
137
|
+
/** Gráficos e indicadores. */
|
|
138
|
+
chartLegend: string;
|
|
139
|
+
chartData: string;
|
|
140
|
+
chartPoint: (series: string, label: string, value: string) => string;
|
|
141
|
+
statUp: string;
|
|
142
|
+
statDown: string;
|
|
143
|
+
statFlat: string;
|
|
144
|
+
statVsPrevious: string;
|
|
145
|
+
/** Botão que alterna a densidade da interface. */
|
|
146
|
+
densityToCompact: string;
|
|
147
|
+
densityToComfortable: string;
|
|
44
148
|
}
|
|
45
149
|
export declare const ZUR_I18N_PT: ZurI18n;
|
|
46
150
|
export declare const ZUR_I18N_EN: ZurI18n;
|
|
@@ -148,14 +252,60 @@ export declare class ZurLogo {
|
|
|
148
252
|
};
|
|
149
253
|
}, {}, never, never, true, never>;
|
|
150
254
|
}
|
|
151
|
-
export type
|
|
255
|
+
export type ZurDensity = 'comfortable' | 'compact';
|
|
256
|
+
/**
|
|
257
|
+
* Densidade da página inteira: aplica `data-density` no `<html>` (controles mais baixos no
|
|
258
|
+
* `compact`), persiste em `localStorage` e começa no confortável. Para uma área só, use a
|
|
259
|
+
* diretiva `zurDensity`.
|
|
260
|
+
*/
|
|
261
|
+
export declare class ZurDensityService {
|
|
262
|
+
private readonly doc;
|
|
263
|
+
readonly density: import("@angular/core").WritableSignal<ZurDensity>;
|
|
264
|
+
constructor();
|
|
265
|
+
set(density: ZurDensity): void;
|
|
266
|
+
toggle(): void;
|
|
267
|
+
private initial;
|
|
268
|
+
private apply;
|
|
269
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDensityService, never>;
|
|
270
|
+
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
271
|
+
}
|
|
272
|
+
/**
|
|
273
|
+
* Densidade só da área marcada: tudo dentro dela usa os controles compactos, sem mexer no
|
|
274
|
+
* resto da página.
|
|
275
|
+
*
|
|
276
|
+
* ```html
|
|
277
|
+
* <section zurDensity>…formulário denso…</section>
|
|
278
|
+
* <section zurDensity="comfortable">…volta ao tamanho normal dentro de uma área compacta…</section>
|
|
279
|
+
* ```
|
|
280
|
+
*/
|
|
281
|
+
export declare class ZurDensityScope {
|
|
282
|
+
readonly zurDensity: import("@angular/core").InputSignal<"" | ZurDensity>;
|
|
283
|
+
protected readonly value: import("@angular/core").Signal<ZurDensity>;
|
|
284
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDensityScope, never>;
|
|
285
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurDensityScope, "[zurDensity]", never, {
|
|
286
|
+
"zurDensity": {
|
|
287
|
+
"alias": "zurDensity";
|
|
288
|
+
"required": false;
|
|
289
|
+
"isSignal": true;
|
|
290
|
+
};
|
|
291
|
+
}, {}, never, never, true, never>;
|
|
292
|
+
}
|
|
293
|
+
/** Botão que alterna a densidade da página (`ZurDensityService`). */
|
|
294
|
+
export declare class ZurDensityToggle {
|
|
295
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
296
|
+
protected readonly service: ZurDensityService;
|
|
297
|
+
protected readonly compact: import("@angular/core").Signal<boolean>;
|
|
298
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDensityToggle, never>;
|
|
299
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurDensityToggle, "zur-density-toggle", never, {}, {}, never, never, true, never>;
|
|
300
|
+
}
|
|
301
|
+
export type ZurButtonVariant = 'primary' | 'secondary' | 'ghost' | 'pill' | 'danger';
|
|
152
302
|
export type ZurButtonSize = 'sm' | 'md' | 'lg';
|
|
153
303
|
/**
|
|
154
304
|
* Botão do Zuri. Aplicado como atributo em <button> ou <a> nativos
|
|
155
305
|
* para preservar semântica e acessibilidade.
|
|
156
306
|
*
|
|
157
307
|
* ```html
|
|
158
|
-
* <button zur-button variant="primary" size="md">
|
|
308
|
+
* <button zur-button variant="primary" size="md">Comprar</button>
|
|
159
309
|
* ```
|
|
160
310
|
*/
|
|
161
311
|
export declare class ZurButton {
|
|
@@ -229,6 +379,50 @@ export declare class ZurAvatar {
|
|
|
229
379
|
};
|
|
230
380
|
}, {}, never, never, true, never>;
|
|
231
381
|
}
|
|
382
|
+
export interface ZurAvatarPerson {
|
|
383
|
+
name: string;
|
|
384
|
+
src?: string | null;
|
|
385
|
+
}
|
|
386
|
+
/**
|
|
387
|
+
* Pilha de avatares sobrepostos com contador do excedente ("+3"). Mostra os `max`
|
|
388
|
+
* primeiros; o resto vira o contador, que também é anunciado por extenso.
|
|
389
|
+
*
|
|
390
|
+
* ```html
|
|
391
|
+
* <zur-avatar-group [people]="equipe" [max]="4" />
|
|
392
|
+
* ```
|
|
393
|
+
*/
|
|
394
|
+
export declare class ZurAvatarGroup {
|
|
395
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
396
|
+
readonly people: import("@angular/core").InputSignal<ZurAvatarPerson[]>;
|
|
397
|
+
readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
398
|
+
readonly size: import("@angular/core").InputSignal<ZurAvatarSize>;
|
|
399
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
400
|
+
protected readonly visible: import("@angular/core").Signal<ZurAvatarPerson[]>;
|
|
401
|
+
protected readonly extra: import("@angular/core").Signal<number>;
|
|
402
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurAvatarGroup, never>;
|
|
403
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurAvatarGroup, "zur-avatar-group", never, {
|
|
404
|
+
"people": {
|
|
405
|
+
"alias": "people";
|
|
406
|
+
"required": false;
|
|
407
|
+
"isSignal": true;
|
|
408
|
+
};
|
|
409
|
+
"max": {
|
|
410
|
+
"alias": "max";
|
|
411
|
+
"required": false;
|
|
412
|
+
"isSignal": true;
|
|
413
|
+
};
|
|
414
|
+
"size": {
|
|
415
|
+
"alias": "size";
|
|
416
|
+
"required": false;
|
|
417
|
+
"isSignal": true;
|
|
418
|
+
};
|
|
419
|
+
"label": {
|
|
420
|
+
"alias": "label";
|
|
421
|
+
"required": false;
|
|
422
|
+
"isSignal": true;
|
|
423
|
+
};
|
|
424
|
+
}, {}, never, never, true, never>;
|
|
425
|
+
}
|
|
232
426
|
/**
|
|
233
427
|
* Campo de texto do Zuri — 56px, label em caption acima,
|
|
234
428
|
* foco com borda 2px ink (sem glow, Airbnb), erro em vermelho semântico.
|
|
@@ -485,180 +679,1654 @@ export declare class ZurTextarea implements ControlValueAccessor {
|
|
|
485
679
|
};
|
|
486
680
|
}, {}, never, never, true, never>;
|
|
487
681
|
}
|
|
682
|
+
export interface ZurComboboxOption {
|
|
683
|
+
value: string;
|
|
684
|
+
label: string;
|
|
685
|
+
/** Linha secundária, mostrada em muted abaixo do rótulo. */
|
|
686
|
+
description?: string;
|
|
687
|
+
}
|
|
488
688
|
/**
|
|
489
|
-
*
|
|
490
|
-
*
|
|
491
|
-
*
|
|
689
|
+
* Select com busca: o usuário digita e a lista filtra (ignora acentos e aceita
|
|
690
|
+
* iniciais). Navegação por setas, Enter escolhe, Esc fecha. Funciona com
|
|
691
|
+
* `ngModel` e formulários reativos; o valor é o `value` da opção (ou `null`).
|
|
692
|
+
*
|
|
693
|
+
* ```html
|
|
694
|
+
* <zur-combobox label="Planta" [options]="plantas" [(ngModel)]="planta" />
|
|
695
|
+
* ```
|
|
492
696
|
*/
|
|
493
|
-
export declare class
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
}
|
|
497
|
-
/** Painel individual dentro de <zur-tabs>. */
|
|
498
|
-
export declare class ZurTab {
|
|
697
|
+
export declare class ZurCombobox implements ControlValueAccessor {
|
|
698
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
699
|
+
private readonly host;
|
|
499
700
|
readonly label: import("@angular/core").InputSignal<string>;
|
|
500
|
-
readonly
|
|
501
|
-
|
|
502
|
-
|
|
701
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
702
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
703
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
704
|
+
readonly options: import("@angular/core").InputSignal<ZurComboboxOption[]>;
|
|
705
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
706
|
+
protected readonly id: string;
|
|
707
|
+
protected readonly listId: string;
|
|
708
|
+
readonly value: import("@angular/core").WritableSignal<string | null>;
|
|
709
|
+
/** Texto digitado; `null` quando o campo só mostra o rótulo escolhido. */
|
|
710
|
+
private readonly typed;
|
|
711
|
+
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
712
|
+
protected readonly activeIndex: import("@angular/core").WritableSignal<number>;
|
|
713
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
714
|
+
private readonly selectedLabel;
|
|
715
|
+
protected readonly query: import("@angular/core").Signal<string>;
|
|
716
|
+
/** Enquanto o usuário não digita, mostra todas as opções. */
|
|
717
|
+
protected readonly filtered: import("@angular/core").Signal<ZurComboboxOption[]>;
|
|
718
|
+
protected onChange: (value: string | null) => void;
|
|
719
|
+
protected onTouched: () => void;
|
|
720
|
+
protected optionId(i: number): string;
|
|
721
|
+
protected isDisabled(): boolean;
|
|
722
|
+
protected openList(): void;
|
|
723
|
+
protected onInput(event: Event): void;
|
|
724
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
725
|
+
select(option: ZurComboboxOption): void;
|
|
726
|
+
clear(): void;
|
|
727
|
+
/** Fecha a lista e restaura o texto para o rótulo escolhido. */
|
|
728
|
+
private closeList;
|
|
729
|
+
protected onFocusOut(event: FocusEvent): void;
|
|
730
|
+
writeValue(value: string | null): void;
|
|
731
|
+
registerOnChange(fn: (value: string | null) => void): void;
|
|
732
|
+
registerOnTouched(fn: () => void): void;
|
|
733
|
+
setDisabledState(isDisabled: boolean): void;
|
|
734
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCombobox, never>;
|
|
735
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurCombobox, "zur-combobox", never, {
|
|
503
736
|
"label": {
|
|
504
737
|
"alias": "label";
|
|
505
|
-
"required":
|
|
738
|
+
"required": false;
|
|
506
739
|
"isSignal": true;
|
|
507
740
|
};
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
/** Tabs com sublinhado 2px ink na aba ativa (Airbnb product-tabs). */
|
|
511
|
-
export declare class ZurTabs {
|
|
512
|
-
readonly index: import("@angular/core").ModelSignal<number>;
|
|
513
|
-
protected readonly tabs: import("@angular/core").Signal<readonly ZurTab[]>;
|
|
514
|
-
constructor();
|
|
515
|
-
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTabs, never>;
|
|
516
|
-
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTabs, "zur-tabs", never, {
|
|
517
|
-
"index": {
|
|
518
|
-
"alias": "index";
|
|
741
|
+
"placeholder": {
|
|
742
|
+
"alias": "placeholder";
|
|
519
743
|
"required": false;
|
|
520
744
|
"isSignal": true;
|
|
521
745
|
};
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
746
|
+
"hint": {
|
|
747
|
+
"alias": "hint";
|
|
748
|
+
"required": false;
|
|
749
|
+
"isSignal": true;
|
|
750
|
+
};
|
|
751
|
+
"error": {
|
|
752
|
+
"alias": "error";
|
|
753
|
+
"required": false;
|
|
754
|
+
"isSignal": true;
|
|
755
|
+
};
|
|
756
|
+
"options": {
|
|
757
|
+
"alias": "options";
|
|
758
|
+
"required": false;
|
|
759
|
+
"isSignal": true;
|
|
760
|
+
};
|
|
761
|
+
"disabled": {
|
|
762
|
+
"alias": "disabled";
|
|
763
|
+
"required": false;
|
|
764
|
+
"isSignal": true;
|
|
765
|
+
};
|
|
766
|
+
}, {}, never, never, true, never>;
|
|
525
767
|
}
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
"selected": "selected";
|
|
532
|
-
}, never, ["*"], true, never>;
|
|
768
|
+
export type ZurDatePickerMode = 'single' | 'range';
|
|
769
|
+
/** Valor do modo `range`. `end` fica `null` enquanto só o início foi escolhido. */
|
|
770
|
+
export interface ZurDateRange {
|
|
771
|
+
start: Date | null;
|
|
772
|
+
end: Date | null;
|
|
533
773
|
}
|
|
534
774
|
/**
|
|
535
|
-
*
|
|
536
|
-
*
|
|
775
|
+
* Campo de data com calendário em painel. No modo `single` o valor é `Date | null`;
|
|
776
|
+
* no modo `range` é `{ start, end }` — o primeiro clique marca o início, o segundo o fim
|
|
777
|
+
* (como na reserva do Airbnb). Teclado na grade: setas, PageUp/PageDown (mês), Home/End
|
|
778
|
+
* (semana), Enter/Espaço escolhe, Esc fecha. Nomes de mês e dia seguem o `locale` do i18n.
|
|
779
|
+
*
|
|
780
|
+
* ```html
|
|
781
|
+
* <zur-date-picker label="Entrega" [min]="hoje" [(ngModel)]="entrega" />
|
|
782
|
+
* <zur-date-picker label="Período" mode="range" [(ngModel)]="periodo" />
|
|
783
|
+
* ```
|
|
537
784
|
*/
|
|
538
|
-
export declare class
|
|
785
|
+
export declare class ZurDatePicker implements ControlValueAccessor {
|
|
786
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
539
787
|
private readonly host;
|
|
788
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
789
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
790
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
791
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
792
|
+
readonly mode: import("@angular/core").InputSignal<ZurDatePickerMode>;
|
|
793
|
+
readonly min: import("@angular/core").InputSignal<Date | null | undefined>;
|
|
794
|
+
readonly max: import("@angular/core").InputSignal<Date | null | undefined>;
|
|
795
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
796
|
+
protected readonly id: string;
|
|
540
797
|
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
798
|
+
protected readonly single: import("@angular/core").WritableSignal<Date | null>;
|
|
799
|
+
protected readonly range: import("@angular/core").WritableSignal<ZurDateRange>;
|
|
800
|
+
/** Mês exibido (dia 1). */
|
|
801
|
+
protected readonly viewMonth: import("@angular/core").WritableSignal<Date>;
|
|
802
|
+
/** Dia com o foco/roving tabindex na grade. */
|
|
803
|
+
protected readonly focused: import("@angular/core").WritableSignal<Date>;
|
|
804
|
+
protected readonly hover: import("@angular/core").WritableSignal<Date | null>;
|
|
805
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
806
|
+
protected onChange: (value: Date | ZurDateRange | null) => void;
|
|
807
|
+
protected onTouched: () => void;
|
|
808
|
+
protected readonly weeks: import("@angular/core").Signal<Date[][]>;
|
|
809
|
+
protected readonly weekdays: import("@angular/core").Signal<{
|
|
810
|
+
short: string;
|
|
811
|
+
long: string;
|
|
812
|
+
}[]>;
|
|
813
|
+
/** "Novembro de 2026": só a primeira letra maiúscula (CSS capitalize faria "De"). */
|
|
814
|
+
protected readonly monthTitle: import("@angular/core").Signal<string>;
|
|
815
|
+
protected readonly displayValue: import("@angular/core").Signal<string>;
|
|
816
|
+
format(date: Date | null): string;
|
|
817
|
+
protected fullDate(date: Date): string;
|
|
818
|
+
protected iso(date: Date): string;
|
|
819
|
+
protected isDisabled(): boolean;
|
|
820
|
+
protected isToday(date: Date): boolean;
|
|
821
|
+
protected isFocusTarget(date: Date): boolean;
|
|
822
|
+
protected isOutOfBounds(date: Date): boolean;
|
|
823
|
+
protected isSelected(date: Date): boolean;
|
|
824
|
+
/** Fim efetivo da faixa: o escolhido ou, enquanto escolhe, o dia sob o mouse. */
|
|
825
|
+
private rangeEnd;
|
|
826
|
+
protected inRange(date: Date): boolean;
|
|
827
|
+
protected isRangeEdge(date: Date, edge: 'start' | 'end'): boolean;
|
|
541
828
|
toggle(): void;
|
|
542
|
-
|
|
829
|
+
private show;
|
|
830
|
+
close(returnFocus?: boolean): void;
|
|
831
|
+
protected shiftMonth(delta: number): void;
|
|
832
|
+
protected pick(date: Date): void;
|
|
833
|
+
protected onGridKeydown(event: KeyboardEvent): void;
|
|
543
834
|
protected onDocumentClick(event: MouseEvent): void;
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
835
|
+
/** Move o foco do navegador para o botão do dia depois da renderização. */
|
|
836
|
+
private focusDay;
|
|
837
|
+
private clamp;
|
|
838
|
+
private firstOfMonth;
|
|
839
|
+
writeValue(value: Date | ZurDateRange | null): void;
|
|
840
|
+
registerOnChange(fn: (value: Date | ZurDateRange | null) => void): void;
|
|
841
|
+
registerOnTouched(fn: () => void): void;
|
|
842
|
+
setDisabledState(isDisabled: boolean): void;
|
|
843
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDatePicker, never>;
|
|
844
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurDatePicker, "zur-date-picker", never, {
|
|
845
|
+
"label": {
|
|
846
|
+
"alias": "label";
|
|
847
|
+
"required": false;
|
|
848
|
+
"isSignal": true;
|
|
849
|
+
};
|
|
850
|
+
"placeholder": {
|
|
851
|
+
"alias": "placeholder";
|
|
852
|
+
"required": false;
|
|
853
|
+
"isSignal": true;
|
|
854
|
+
};
|
|
855
|
+
"hint": {
|
|
856
|
+
"alias": "hint";
|
|
857
|
+
"required": false;
|
|
858
|
+
"isSignal": true;
|
|
859
|
+
};
|
|
860
|
+
"error": {
|
|
861
|
+
"alias": "error";
|
|
862
|
+
"required": false;
|
|
863
|
+
"isSignal": true;
|
|
864
|
+
};
|
|
865
|
+
"mode": {
|
|
866
|
+
"alias": "mode";
|
|
867
|
+
"required": false;
|
|
868
|
+
"isSignal": true;
|
|
869
|
+
};
|
|
870
|
+
"min": {
|
|
871
|
+
"alias": "min";
|
|
872
|
+
"required": false;
|
|
873
|
+
"isSignal": true;
|
|
874
|
+
};
|
|
875
|
+
"max": {
|
|
876
|
+
"alias": "max";
|
|
877
|
+
"required": false;
|
|
878
|
+
"isSignal": true;
|
|
879
|
+
};
|
|
880
|
+
"disabled": {
|
|
881
|
+
"alias": "disabled";
|
|
559
882
|
"required": false;
|
|
560
883
|
"isSignal": true;
|
|
561
884
|
};
|
|
562
885
|
}, {}, never, never, true, never>;
|
|
563
886
|
}
|
|
564
|
-
export type
|
|
887
|
+
export type ZurUploadStatus = 'pending' | 'uploading' | 'done' | 'error';
|
|
888
|
+
/** Um arquivo na lista do `zur-file-upload`. Atualize `progress`/`status` de fora. */
|
|
889
|
+
export interface ZurUploadFile {
|
|
890
|
+
id: string;
|
|
891
|
+
file: File;
|
|
892
|
+
/** 0–100 enquanto envia; `null` esconde a barra. */
|
|
893
|
+
progress: number | null;
|
|
894
|
+
status: ZurUploadStatus;
|
|
895
|
+
error?: string;
|
|
896
|
+
}
|
|
897
|
+
/** Formata bytes em B, KB ou MB no locale informado. */
|
|
898
|
+
export declare function zurFormatBytes(bytes: number, locale?: string): string;
|
|
899
|
+
/** Confere um arquivo contra uma lista no formato do atributo `accept` (`.pdf,image/*`). */
|
|
900
|
+
export declare function zurAcceptsFile(file: File, accept: string): boolean;
|
|
565
901
|
/**
|
|
566
|
-
*
|
|
567
|
-
*
|
|
902
|
+
* Área de envio de arquivos: arrastar e soltar ou escolher no computador, com
|
|
903
|
+
* validação de tipo (`accept`) e tamanho (`maxSize`, em bytes). Os arquivos aceitos
|
|
904
|
+
* entram em `files` (two-way) e saem em `filesAdded`; o componente não faz o envio —
|
|
905
|
+
* quem usa atualiza `progress` e `status` de cada item.
|
|
568
906
|
*
|
|
569
907
|
* ```html
|
|
570
|
-
* <zur-
|
|
571
|
-
*
|
|
572
|
-
* </zur-sidenav>
|
|
908
|
+
* <zur-file-upload label="Fotos da planta" accept="image/*" [maxSize]="5_000_000"
|
|
909
|
+
* multiple [(files)]="fotos" (filesAdded)="enviar($event)" />
|
|
573
910
|
* ```
|
|
574
911
|
*/
|
|
575
|
-
export declare class
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
/**
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
readonly
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
912
|
+
export declare class ZurFileUpload {
|
|
913
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
914
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
915
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
916
|
+
/** Mesmo formato do atributo `accept` do input: `.pdf,image/*`. */
|
|
917
|
+
readonly accept: import("@angular/core").InputSignal<string>;
|
|
918
|
+
/** Tamanho máximo por arquivo, em bytes. `0` = sem limite. */
|
|
919
|
+
readonly maxSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
920
|
+
readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
921
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
922
|
+
/** Lista de arquivos aceitos (two-way). */
|
|
923
|
+
readonly files: import("@angular/core").ModelSignal<ZurUploadFile[]>;
|
|
924
|
+
/** Arquivos que acabaram de ser aceitos. */
|
|
925
|
+
readonly filesAdded: import("@angular/core").OutputEmitterRef<ZurUploadFile[]>;
|
|
926
|
+
readonly fileRemoved: import("@angular/core").OutputEmitterRef<ZurUploadFile>;
|
|
927
|
+
protected readonly id: string;
|
|
928
|
+
protected readonly dragging: import("@angular/core").WritableSignal<boolean>;
|
|
929
|
+
protected readonly rejected: import("@angular/core").WritableSignal<string[]>;
|
|
930
|
+
protected size(bytes: number): string;
|
|
931
|
+
/** Valida e adiciona arquivos — também pode ser chamado de fora. */
|
|
932
|
+
addFiles(list: FileList | File[]): void;
|
|
933
|
+
remove(item: ZurUploadFile): void;
|
|
934
|
+
protected onPick(event: Event): void;
|
|
935
|
+
protected onDragOver(event: DragEvent): void;
|
|
936
|
+
protected onDragLeave(event: DragEvent): void;
|
|
937
|
+
protected onDrop(event: DragEvent): void;
|
|
938
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurFileUpload, never>;
|
|
939
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurFileUpload, "zur-file-upload", never, {
|
|
940
|
+
"label": {
|
|
941
|
+
"alias": "label";
|
|
594
942
|
"required": false;
|
|
595
943
|
"isSignal": true;
|
|
596
944
|
};
|
|
597
|
-
"
|
|
598
|
-
"alias": "
|
|
945
|
+
"hint": {
|
|
946
|
+
"alias": "hint";
|
|
599
947
|
"required": false;
|
|
600
948
|
"isSignal": true;
|
|
601
949
|
};
|
|
602
|
-
|
|
950
|
+
"accept": {
|
|
951
|
+
"alias": "accept";
|
|
952
|
+
"required": false;
|
|
953
|
+
"isSignal": true;
|
|
954
|
+
};
|
|
955
|
+
"maxSize": {
|
|
956
|
+
"alias": "maxSize";
|
|
957
|
+
"required": false;
|
|
958
|
+
"isSignal": true;
|
|
959
|
+
};
|
|
960
|
+
"multiple": {
|
|
961
|
+
"alias": "multiple";
|
|
962
|
+
"required": false;
|
|
963
|
+
"isSignal": true;
|
|
964
|
+
};
|
|
965
|
+
"disabled": {
|
|
966
|
+
"alias": "disabled";
|
|
967
|
+
"required": false;
|
|
968
|
+
"isSignal": true;
|
|
969
|
+
};
|
|
970
|
+
"files": {
|
|
971
|
+
"alias": "files";
|
|
972
|
+
"required": false;
|
|
973
|
+
"isSignal": true;
|
|
974
|
+
};
|
|
975
|
+
}, {
|
|
976
|
+
"files": "filesChange";
|
|
977
|
+
"filesAdded": "filesAdded";
|
|
978
|
+
"fileRemoved": "fileRemoved";
|
|
979
|
+
}, never, never, true, never>;
|
|
603
980
|
}
|
|
604
|
-
/**
|
|
605
|
-
|
|
981
|
+
/**
|
|
982
|
+
* Campo de tags: o usuário digita e Enter (ou vírgula) vira um chip; Backspace no
|
|
983
|
+
* campo vazio remove o último. Ignora repetidos (sem diferenciar acento/caixa).
|
|
984
|
+
* O valor é `string[]` e funciona com `ngModel` e formulários reativos.
|
|
985
|
+
*
|
|
986
|
+
* ```html
|
|
987
|
+
* <zur-chips label="Ambientes" placeholder="Sala, varanda…" [(ngModel)]="ambientes" />
|
|
988
|
+
* ```
|
|
989
|
+
*/
|
|
990
|
+
export declare class ZurChips implements ControlValueAccessor {
|
|
991
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
992
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
993
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
994
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
995
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
996
|
+
/** Quantidade máxima de chips; `0` = sem limite. */
|
|
997
|
+
readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
998
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
999
|
+
protected readonly id: string;
|
|
1000
|
+
readonly value: import("@angular/core").WritableSignal<string[]>;
|
|
1001
|
+
protected readonly draft: import("@angular/core").WritableSignal<string>;
|
|
1002
|
+
protected readonly announcement: import("@angular/core").WritableSignal<string>;
|
|
1003
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1004
|
+
protected onChange: (value: string[]) => void;
|
|
1005
|
+
protected onTouched: () => void;
|
|
1006
|
+
protected isDisabled(): boolean;
|
|
1007
|
+
protected full(): boolean;
|
|
1008
|
+
protected onInput(event: Event): void;
|
|
1009
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1010
|
+
/** Transforma o texto digitado em chip. */
|
|
1011
|
+
protected commit(): void;
|
|
1012
|
+
add(text: string): void;
|
|
1013
|
+
remove(chip: string): void;
|
|
1014
|
+
writeValue(value: string[] | null): void;
|
|
1015
|
+
registerOnChange(fn: (value: string[]) => void): void;
|
|
1016
|
+
registerOnTouched(fn: () => void): void;
|
|
1017
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1018
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChips, never>;
|
|
1019
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChips, "zur-chips", never, {
|
|
1020
|
+
"label": {
|
|
1021
|
+
"alias": "label";
|
|
1022
|
+
"required": false;
|
|
1023
|
+
"isSignal": true;
|
|
1024
|
+
};
|
|
1025
|
+
"placeholder": {
|
|
1026
|
+
"alias": "placeholder";
|
|
1027
|
+
"required": false;
|
|
1028
|
+
"isSignal": true;
|
|
1029
|
+
};
|
|
1030
|
+
"hint": {
|
|
1031
|
+
"alias": "hint";
|
|
1032
|
+
"required": false;
|
|
1033
|
+
"isSignal": true;
|
|
1034
|
+
};
|
|
1035
|
+
"error": {
|
|
1036
|
+
"alias": "error";
|
|
1037
|
+
"required": false;
|
|
1038
|
+
"isSignal": true;
|
|
1039
|
+
};
|
|
1040
|
+
"max": {
|
|
1041
|
+
"alias": "max";
|
|
1042
|
+
"required": false;
|
|
1043
|
+
"isSignal": true;
|
|
1044
|
+
};
|
|
1045
|
+
"disabled": {
|
|
1046
|
+
"alias": "disabled";
|
|
1047
|
+
"required": false;
|
|
1048
|
+
"isSignal": true;
|
|
1049
|
+
};
|
|
1050
|
+
}, {}, never, never, true, never>;
|
|
1051
|
+
}
|
|
1052
|
+
/**
|
|
1053
|
+
* Controle deslizante. Com `range`, tem dois controles e o valor é `[mínimo, máximo]`;
|
|
1054
|
+
* sem, é um número. Teclado: setas (±step), PageUp/PageDown (±10 steps), Home/End.
|
|
1055
|
+
* Clique na trilha move o controle mais próximo; arrastar funciona com mouse e toque.
|
|
1056
|
+
*
|
|
1057
|
+
* ```html
|
|
1058
|
+
* <zur-slider label="Preço" range [min]="0" [max]="500" [step]="10"
|
|
1059
|
+
* [format]="reais" [(ngModel)]="faixa" />
|
|
1060
|
+
* ```
|
|
1061
|
+
*/
|
|
1062
|
+
export declare class ZurSlider implements ControlValueAccessor {
|
|
1063
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1064
|
+
private readonly host;
|
|
1065
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1066
|
+
readonly min: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1067
|
+
readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1068
|
+
readonly step: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1069
|
+
/** Dois controles: o valor vira `[mínimo, máximo]`. */
|
|
1070
|
+
readonly range: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1071
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1072
|
+
/** Como mostrar/anunciar o valor (ex.: moeda). */
|
|
1073
|
+
readonly format: import("@angular/core").InputSignal<(value: number) => string>;
|
|
1074
|
+
protected readonly id: string;
|
|
1075
|
+
/** `null` = ainda sem valor: usa o padrão (mínimo, ou a trilha toda no modo faixa). */
|
|
1076
|
+
private readonly lowValue;
|
|
1077
|
+
private readonly highValue;
|
|
1078
|
+
protected readonly low: import("@angular/core").Signal<number>;
|
|
1079
|
+
protected readonly high: import("@angular/core").Signal<number>;
|
|
1080
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1081
|
+
protected dragging: 'low' | 'high' | null;
|
|
1082
|
+
protected readonly thumbs: import("@angular/core").Signal<("low" | "high")[]>;
|
|
1083
|
+
protected onChange: (value: number | [number, number]) => void;
|
|
1084
|
+
protected onTouched: () => void;
|
|
1085
|
+
/** No modo simples o valor vive em `high`; `low` é o mínimo da trilha. */
|
|
1086
|
+
value(): number | [number, number];
|
|
1087
|
+
protected isDisabled(): boolean;
|
|
1088
|
+
protected percent(value: number): number;
|
|
1089
|
+
protected thumbLabel(thumb: 'low' | 'high'): string | null;
|
|
1090
|
+
private snap;
|
|
1091
|
+
/** Atualiza um controle respeitando o outro (low ≤ high). */
|
|
1092
|
+
setThumb(thumb: 'low' | 'high', raw: number): void;
|
|
1093
|
+
protected onKeydown(event: KeyboardEvent, thumb: 'low' | 'high'): void;
|
|
1094
|
+
private valueAt;
|
|
1095
|
+
protected onTrackPointerDown(event: PointerEvent): void;
|
|
1096
|
+
protected onPointerMove(event: PointerEvent): void;
|
|
1097
|
+
writeValue(value: number | [number, number] | null): void;
|
|
1098
|
+
registerOnChange(fn: (value: number | [number, number]) => void): void;
|
|
1099
|
+
registerOnTouched(fn: () => void): void;
|
|
1100
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1101
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSlider, never>;
|
|
1102
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSlider, "zur-slider", never, {
|
|
1103
|
+
"label": {
|
|
1104
|
+
"alias": "label";
|
|
1105
|
+
"required": false;
|
|
1106
|
+
"isSignal": true;
|
|
1107
|
+
};
|
|
1108
|
+
"min": {
|
|
1109
|
+
"alias": "min";
|
|
1110
|
+
"required": false;
|
|
1111
|
+
"isSignal": true;
|
|
1112
|
+
};
|
|
1113
|
+
"max": {
|
|
1114
|
+
"alias": "max";
|
|
1115
|
+
"required": false;
|
|
1116
|
+
"isSignal": true;
|
|
1117
|
+
};
|
|
1118
|
+
"step": {
|
|
1119
|
+
"alias": "step";
|
|
1120
|
+
"required": false;
|
|
1121
|
+
"isSignal": true;
|
|
1122
|
+
};
|
|
1123
|
+
"range": {
|
|
1124
|
+
"alias": "range";
|
|
1125
|
+
"required": false;
|
|
1126
|
+
"isSignal": true;
|
|
1127
|
+
};
|
|
1128
|
+
"disabled": {
|
|
1129
|
+
"alias": "disabled";
|
|
1130
|
+
"required": false;
|
|
1131
|
+
"isSignal": true;
|
|
1132
|
+
};
|
|
1133
|
+
"format": {
|
|
1134
|
+
"alias": "format";
|
|
1135
|
+
"required": false;
|
|
1136
|
+
"isSignal": true;
|
|
1137
|
+
};
|
|
1138
|
+
}, {}, never, never, true, never>;
|
|
1139
|
+
}
|
|
1140
|
+
export interface ZurSegmentedOption {
|
|
1141
|
+
value: string;
|
|
1142
|
+
label: string;
|
|
1143
|
+
}
|
|
1144
|
+
export type ZurSegmentedSize = 'sm' | 'md';
|
|
1145
|
+
/**
|
|
1146
|
+
* Alternador em pílulas para poucas opções mutuamente exclusivas (visão em
|
|
1147
|
+
* lista/grade, período). É um `radiogroup`: setas trocam a opção, Tab sai do grupo.
|
|
1148
|
+
*
|
|
1149
|
+
* ```html
|
|
1150
|
+
* <zur-segmented label="Visualização" [options]="visoes" [(ngModel)]="visao" />
|
|
1151
|
+
* ```
|
|
1152
|
+
*/
|
|
1153
|
+
export declare class ZurSegmented implements ControlValueAccessor {
|
|
1154
|
+
private readonly host;
|
|
1155
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1156
|
+
readonly options: import("@angular/core").InputSignal<ZurSegmentedOption[]>;
|
|
1157
|
+
readonly size: import("@angular/core").InputSignal<ZurSegmentedSize>;
|
|
1158
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1159
|
+
readonly value: import("@angular/core").WritableSignal<string | null>;
|
|
1160
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1161
|
+
protected onChange: (value: string) => void;
|
|
1162
|
+
protected onTouched: () => void;
|
|
1163
|
+
protected isDisabled(): boolean;
|
|
1164
|
+
/** O item marcado (ou o primeiro, se nenhum) recebe o Tab. */
|
|
1165
|
+
protected isTabStop(i: number): boolean;
|
|
1166
|
+
select(value: string): void;
|
|
1167
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1168
|
+
writeValue(value: string | null): void;
|
|
1169
|
+
registerOnChange(fn: (value: string) => void): void;
|
|
1170
|
+
registerOnTouched(fn: () => void): void;
|
|
1171
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1172
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSegmented, never>;
|
|
1173
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSegmented, "zur-segmented", never, {
|
|
1174
|
+
"label": {
|
|
1175
|
+
"alias": "label";
|
|
1176
|
+
"required": false;
|
|
1177
|
+
"isSignal": true;
|
|
1178
|
+
};
|
|
1179
|
+
"options": {
|
|
1180
|
+
"alias": "options";
|
|
1181
|
+
"required": false;
|
|
1182
|
+
"isSignal": true;
|
|
1183
|
+
};
|
|
1184
|
+
"size": {
|
|
1185
|
+
"alias": "size";
|
|
1186
|
+
"required": false;
|
|
1187
|
+
"isSignal": true;
|
|
1188
|
+
};
|
|
1189
|
+
"disabled": {
|
|
1190
|
+
"alias": "disabled";
|
|
1191
|
+
"required": false;
|
|
1192
|
+
"isSignal": true;
|
|
1193
|
+
};
|
|
1194
|
+
}, {}, never, never, true, never>;
|
|
1195
|
+
}
|
|
1196
|
+
/**
|
|
1197
|
+
* Lê um número digitado em qualquer formato comum: "1.234,5", "1,234.5", "12,5", "12.5".
|
|
1198
|
+
* O último separador é o decimal. Devolve `null` se não houver número.
|
|
1199
|
+
*/
|
|
1200
|
+
export declare function zurParseNumber(text: string): number | null;
|
|
1201
|
+
/**
|
|
1202
|
+
* Campo numérico com botões − / +. Setas ↑↓ mudam por `step`, PageUp/PageDown por 10 passos,
|
|
1203
|
+
* Home/End vão a `min`/`max`. O valor é `number | null` e é limitado a `min`/`max`.
|
|
1204
|
+
*
|
|
1205
|
+
* ```html
|
|
1206
|
+
* <zur-number-input label="Quantidade" [min]="1" [max]="20" [(ngModel)]="qtd" />
|
|
1207
|
+
* ```
|
|
1208
|
+
*/
|
|
1209
|
+
export declare class ZurNumberInput implements ControlValueAccessor {
|
|
1210
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1211
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1212
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
1213
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
1214
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
1215
|
+
readonly min: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
|
|
1216
|
+
readonly max: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
|
|
1217
|
+
readonly step: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1218
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1219
|
+
protected readonly id: string;
|
|
1220
|
+
readonly value: import("@angular/core").WritableSignal<number | null>;
|
|
1221
|
+
/** Texto enquanto o usuário digita; `null` = mostrar o valor formatado. */
|
|
1222
|
+
private readonly typed;
|
|
1223
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1224
|
+
protected onChange: (value: number | null) => void;
|
|
1225
|
+
protected onTouched: () => void;
|
|
1226
|
+
protected readonly text: import("@angular/core").Signal<string>;
|
|
1227
|
+
protected readonly atMin: import("@angular/core").Signal<boolean>;
|
|
1228
|
+
protected readonly atMax: import("@angular/core").Signal<boolean>;
|
|
1229
|
+
protected isDisabled(): boolean;
|
|
1230
|
+
private clamp;
|
|
1231
|
+
private setValue;
|
|
1232
|
+
/** Soma `direction` passos (negativo diminui). Sem valor, parte do mínimo ou de zero. */
|
|
1233
|
+
stepBy(direction: number, multiplier?: number): void;
|
|
1234
|
+
protected onInput(event: Event): void;
|
|
1235
|
+
/** Converte o texto digitado em número (ao sair do campo ou com Enter). */
|
|
1236
|
+
protected commit(): void;
|
|
1237
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1238
|
+
writeValue(value: number | null): void;
|
|
1239
|
+
registerOnChange(fn: (value: number | null) => void): void;
|
|
1240
|
+
registerOnTouched(fn: () => void): void;
|
|
1241
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1242
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurNumberInput, never>;
|
|
1243
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurNumberInput, "zur-number-input", never, {
|
|
1244
|
+
"label": {
|
|
1245
|
+
"alias": "label";
|
|
1246
|
+
"required": false;
|
|
1247
|
+
"isSignal": true;
|
|
1248
|
+
};
|
|
1249
|
+
"placeholder": {
|
|
1250
|
+
"alias": "placeholder";
|
|
1251
|
+
"required": false;
|
|
1252
|
+
"isSignal": true;
|
|
1253
|
+
};
|
|
1254
|
+
"hint": {
|
|
1255
|
+
"alias": "hint";
|
|
1256
|
+
"required": false;
|
|
1257
|
+
"isSignal": true;
|
|
1258
|
+
};
|
|
1259
|
+
"error": {
|
|
1260
|
+
"alias": "error";
|
|
1261
|
+
"required": false;
|
|
1262
|
+
"isSignal": true;
|
|
1263
|
+
};
|
|
1264
|
+
"min": {
|
|
1265
|
+
"alias": "min";
|
|
1266
|
+
"required": false;
|
|
1267
|
+
"isSignal": true;
|
|
1268
|
+
};
|
|
1269
|
+
"max": {
|
|
1270
|
+
"alias": "max";
|
|
1271
|
+
"required": false;
|
|
1272
|
+
"isSignal": true;
|
|
1273
|
+
};
|
|
1274
|
+
"step": {
|
|
1275
|
+
"alias": "step";
|
|
1276
|
+
"required": false;
|
|
1277
|
+
"isSignal": true;
|
|
1278
|
+
};
|
|
1279
|
+
"disabled": {
|
|
1280
|
+
"alias": "disabled";
|
|
1281
|
+
"required": false;
|
|
1282
|
+
"isSignal": true;
|
|
1283
|
+
};
|
|
1284
|
+
}, {}, never, never, true, never>;
|
|
1285
|
+
}
|
|
1286
|
+
/**
|
|
1287
|
+
* Código de verificação em caixinhas (SMS, e-mail, 2FA). Digitar avança, Backspace volta,
|
|
1288
|
+
* ←/→ andam entre as caixas e colar distribui os caracteres. O valor é a string digitada;
|
|
1289
|
+
* `completed` dispara quando todas as caixas estão preenchidas. As caixas sempre seguem a
|
|
1290
|
+
* ordem esquerda→direita, mesmo em páginas RTL (números não se invertem).
|
|
1291
|
+
*
|
|
1292
|
+
* ```html
|
|
1293
|
+
* <zur-otp-input label="Código enviado por SMS" [length]="6" (completed)="verificar($event)" />
|
|
1294
|
+
* ```
|
|
1295
|
+
*/
|
|
1296
|
+
export declare class ZurOtpInput implements ControlValueAccessor {
|
|
1297
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1298
|
+
private readonly host;
|
|
1299
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1300
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
1301
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
1302
|
+
readonly length: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1303
|
+
/** `numeric` aceita só dígitos; `text` aceita letras e números. */
|
|
1304
|
+
readonly mode: import("@angular/core").InputSignal<"text" | "numeric">;
|
|
1305
|
+
/** Esconde os caracteres como numa senha. */
|
|
1306
|
+
readonly masked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1307
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1308
|
+
/** Todas as caixas preenchidas: emite o código. */
|
|
1309
|
+
readonly completed: import("@angular/core").OutputEmitterRef<string>;
|
|
1310
|
+
protected readonly id: string;
|
|
1311
|
+
private readonly chars;
|
|
1312
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1313
|
+
protected readonly boxes: import("@angular/core").Signal<string[]>;
|
|
1314
|
+
readonly value: import("@angular/core").Signal<string>;
|
|
1315
|
+
protected onChange: (value: string) => void;
|
|
1316
|
+
protected onTouched: () => void;
|
|
1317
|
+
protected isDisabled(): boolean;
|
|
1318
|
+
private accept;
|
|
1319
|
+
private focusBox;
|
|
1320
|
+
/** Escreve `chars` a partir da caixa `start` e devolve a próxima caixa livre. */
|
|
1321
|
+
private fill;
|
|
1322
|
+
private emit;
|
|
1323
|
+
protected onInput(i: number, event: Event): void;
|
|
1324
|
+
protected onKeydown(i: number, event: KeyboardEvent): void;
|
|
1325
|
+
protected onPaste(event: ClipboardEvent): void;
|
|
1326
|
+
writeValue(value: string | null): void;
|
|
1327
|
+
registerOnChange(fn: (value: string) => void): void;
|
|
1328
|
+
registerOnTouched(fn: () => void): void;
|
|
1329
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1330
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurOtpInput, never>;
|
|
1331
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurOtpInput, "zur-otp-input", never, {
|
|
1332
|
+
"label": {
|
|
1333
|
+
"alias": "label";
|
|
1334
|
+
"required": false;
|
|
1335
|
+
"isSignal": true;
|
|
1336
|
+
};
|
|
1337
|
+
"hint": {
|
|
1338
|
+
"alias": "hint";
|
|
1339
|
+
"required": false;
|
|
1340
|
+
"isSignal": true;
|
|
1341
|
+
};
|
|
1342
|
+
"error": {
|
|
1343
|
+
"alias": "error";
|
|
1344
|
+
"required": false;
|
|
1345
|
+
"isSignal": true;
|
|
1346
|
+
};
|
|
1347
|
+
"length": {
|
|
1348
|
+
"alias": "length";
|
|
1349
|
+
"required": false;
|
|
1350
|
+
"isSignal": true;
|
|
1351
|
+
};
|
|
1352
|
+
"mode": {
|
|
1353
|
+
"alias": "mode";
|
|
1354
|
+
"required": false;
|
|
1355
|
+
"isSignal": true;
|
|
1356
|
+
};
|
|
1357
|
+
"masked": {
|
|
1358
|
+
"alias": "masked";
|
|
1359
|
+
"required": false;
|
|
1360
|
+
"isSignal": true;
|
|
1361
|
+
};
|
|
1362
|
+
"disabled": {
|
|
1363
|
+
"alias": "disabled";
|
|
1364
|
+
"required": false;
|
|
1365
|
+
"isSignal": true;
|
|
1366
|
+
};
|
|
1367
|
+
}, {
|
|
1368
|
+
"completed": "completed";
|
|
1369
|
+
}, never, never, true, never>;
|
|
1370
|
+
}
|
|
1371
|
+
/**
|
|
1372
|
+
* Avaliação por estrelas. Editável, é um `radiogroup` (setas trocam a nota) e funciona com
|
|
1373
|
+
* `ngModel`/formulários. Com `readonly`, é uma imagem com texto ("4,5 de 5") e aceita
|
|
1374
|
+
* valores fracionários. As estrelas são em ink (como no Airbnb): menta fica para ação.
|
|
1375
|
+
*
|
|
1376
|
+
* ```html
|
|
1377
|
+
* <zur-rating label="Sua nota" [(ngModel)]="nota" />
|
|
1378
|
+
* <zur-rating readonly [value]="4.5" />
|
|
1379
|
+
* ```
|
|
1380
|
+
*/
|
|
1381
|
+
export declare class ZurRating implements ControlValueAccessor {
|
|
1382
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1383
|
+
private readonly host;
|
|
1384
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1385
|
+
readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1386
|
+
readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg">;
|
|
1387
|
+
/** Só mostra a nota (aceita fração, ex.: 4,5). */
|
|
1388
|
+
readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1389
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1390
|
+
/** Nota exibida no modo `readonly` quando não há formulário ligado. */
|
|
1391
|
+
readonly valueInput: import("@angular/core").InputSignalWithTransform<number | null, unknown>;
|
|
1392
|
+
protected readonly uid: string;
|
|
1393
|
+
protected readonly path = "M12 2.8l2.9 6 6.6.9-4.8 4.6 1.2 6.5L12 17.7 6.1 20.8l1.2-6.5L2.5 9.7l6.6-.9z";
|
|
1394
|
+
private readonly model;
|
|
1395
|
+
protected readonly hover: import("@angular/core").WritableSignal<number>;
|
|
1396
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1397
|
+
protected onChange: (value: number) => void;
|
|
1398
|
+
protected onTouched: () => void;
|
|
1399
|
+
readonly value: import("@angular/core").Signal<number>;
|
|
1400
|
+
protected readonly stars: import("@angular/core").Signal<number[]>;
|
|
1401
|
+
protected readonly shown: import("@angular/core").Signal<number>;
|
|
1402
|
+
protected readonly summary: import("@angular/core").Signal<string>;
|
|
1403
|
+
protected isDisabled(): boolean;
|
|
1404
|
+
/** Quanto da estrela `n` é preenchido (0–1), para notas fracionárias. */
|
|
1405
|
+
protected fill(n: number): number;
|
|
1406
|
+
protected isTabStop(n: number): boolean;
|
|
1407
|
+
choose(n: number): void;
|
|
1408
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
1409
|
+
writeValue(value: number | null): void;
|
|
1410
|
+
registerOnChange(fn: (value: number) => void): void;
|
|
1411
|
+
registerOnTouched(fn: () => void): void;
|
|
1412
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1413
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurRating, never>;
|
|
1414
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurRating, "zur-rating", never, {
|
|
1415
|
+
"label": {
|
|
1416
|
+
"alias": "label";
|
|
1417
|
+
"required": false;
|
|
1418
|
+
"isSignal": true;
|
|
1419
|
+
};
|
|
1420
|
+
"max": {
|
|
1421
|
+
"alias": "max";
|
|
1422
|
+
"required": false;
|
|
1423
|
+
"isSignal": true;
|
|
1424
|
+
};
|
|
1425
|
+
"size": {
|
|
1426
|
+
"alias": "size";
|
|
1427
|
+
"required": false;
|
|
1428
|
+
"isSignal": true;
|
|
1429
|
+
};
|
|
1430
|
+
"readonly": {
|
|
1431
|
+
"alias": "readonly";
|
|
1432
|
+
"required": false;
|
|
1433
|
+
"isSignal": true;
|
|
1434
|
+
};
|
|
1435
|
+
"disabled": {
|
|
1436
|
+
"alias": "disabled";
|
|
1437
|
+
"required": false;
|
|
1438
|
+
"isSignal": true;
|
|
1439
|
+
};
|
|
1440
|
+
"valueInput": {
|
|
1441
|
+
"alias": "value";
|
|
1442
|
+
"required": false;
|
|
1443
|
+
"isSignal": true;
|
|
1444
|
+
};
|
|
1445
|
+
}, {}, never, never, true, never>;
|
|
1446
|
+
}
|
|
1447
|
+
interface Column {
|
|
1448
|
+
id: 'hour' | 'minute' | 'period';
|
|
1449
|
+
label: string;
|
|
1450
|
+
options: {
|
|
1451
|
+
value: number;
|
|
1452
|
+
label: string;
|
|
1453
|
+
disabled: boolean;
|
|
1454
|
+
selected: boolean;
|
|
1455
|
+
}[];
|
|
1456
|
+
}
|
|
1457
|
+
/** `'14:30'` → minutos desde meia-noite (ou `null` se inválido). */
|
|
1458
|
+
export declare function zurTimeToMinutes(time: string | null | undefined): number | null;
|
|
1459
|
+
/**
|
|
1460
|
+
* Seletor de horário: campo que abre um painel com listas de horas e minutos (e AM/PM
|
|
1461
|
+
* quando o idioma usa 12 horas). O valor é `'HH:mm'` (24h), em formulários ou `ngModel`.
|
|
1462
|
+
* Teclado: ↑↓ dentro da lista, ←→ entre listas, Enter/Espaço escolhe, Esc fecha.
|
|
1463
|
+
*
|
|
1464
|
+
* ```html
|
|
1465
|
+
* <zur-time-picker label="Retirada" min="09:00" max="18:00" [minuteStep]="15" [(ngModel)]="hora" />
|
|
1466
|
+
* ```
|
|
1467
|
+
*/
|
|
1468
|
+
export declare class ZurTimePicker implements ControlValueAccessor {
|
|
1469
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1470
|
+
private readonly host;
|
|
1471
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1472
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
1473
|
+
readonly hint: import("@angular/core").InputSignal<string>;
|
|
1474
|
+
readonly error: import("@angular/core").InputSignal<string>;
|
|
1475
|
+
/** Intervalo entre os minutos listados (padrão 5). */
|
|
1476
|
+
readonly minuteStep: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1477
|
+
/** Menor e maior horário aceitos, em `'HH:mm'`. */
|
|
1478
|
+
readonly min: import("@angular/core").InputSignal<string | null | undefined>;
|
|
1479
|
+
readonly max: import("@angular/core").InputSignal<string | null | undefined>;
|
|
1480
|
+
/** `null` = decide pelo idioma (en-US usa 12h, pt-BR usa 24h). */
|
|
1481
|
+
readonly hour12: import("@angular/core").InputSignal<boolean | null>;
|
|
1482
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1483
|
+
protected readonly id: string;
|
|
1484
|
+
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
1485
|
+
private readonly hour;
|
|
1486
|
+
private readonly minute;
|
|
1487
|
+
protected readonly cvaDisabled: import("@angular/core").WritableSignal<boolean>;
|
|
1488
|
+
protected onChange: (value: string | null) => void;
|
|
1489
|
+
protected onTouched: () => void;
|
|
1490
|
+
protected readonly is12h: import("@angular/core").Signal<boolean>;
|
|
1491
|
+
/** Valor no formato do formulário, ou `null` enquanto incompleto. */
|
|
1492
|
+
readonly value: import("@angular/core").Signal<string | null>;
|
|
1493
|
+
protected readonly display: import("@angular/core").Signal<string>;
|
|
1494
|
+
private inRange;
|
|
1495
|
+
protected readonly columns: import("@angular/core").Signal<Column[]>;
|
|
1496
|
+
protected isDisabled(): boolean;
|
|
1497
|
+
/** O item escolhido (ou o primeiro) de cada lista recebe o Tab. */
|
|
1498
|
+
protected isTabStop(col: Column, index: number): boolean;
|
|
1499
|
+
toggle(): void;
|
|
1500
|
+
private show;
|
|
1501
|
+
close(returnFocus?: boolean): void;
|
|
1502
|
+
protected pick(column: Column['id'], value: number): void;
|
|
1503
|
+
private firstValidMinute;
|
|
1504
|
+
private firstValidHour;
|
|
1505
|
+
protected onKeydown(event: KeyboardEvent, c: number, o: number): void;
|
|
1506
|
+
protected onDocumentClick(event: MouseEvent): void;
|
|
1507
|
+
writeValue(value: string | null): void;
|
|
1508
|
+
registerOnChange(fn: (value: string | null) => void): void;
|
|
1509
|
+
registerOnTouched(fn: () => void): void;
|
|
1510
|
+
setDisabledState(isDisabled: boolean): void;
|
|
1511
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTimePicker, never>;
|
|
1512
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTimePicker, "zur-time-picker", never, {
|
|
1513
|
+
"label": {
|
|
1514
|
+
"alias": "label";
|
|
1515
|
+
"required": false;
|
|
1516
|
+
"isSignal": true;
|
|
1517
|
+
};
|
|
1518
|
+
"placeholder": {
|
|
1519
|
+
"alias": "placeholder";
|
|
1520
|
+
"required": false;
|
|
1521
|
+
"isSignal": true;
|
|
1522
|
+
};
|
|
1523
|
+
"hint": {
|
|
1524
|
+
"alias": "hint";
|
|
1525
|
+
"required": false;
|
|
1526
|
+
"isSignal": true;
|
|
1527
|
+
};
|
|
1528
|
+
"error": {
|
|
1529
|
+
"alias": "error";
|
|
1530
|
+
"required": false;
|
|
1531
|
+
"isSignal": true;
|
|
1532
|
+
};
|
|
1533
|
+
"minuteStep": {
|
|
1534
|
+
"alias": "minuteStep";
|
|
1535
|
+
"required": false;
|
|
1536
|
+
"isSignal": true;
|
|
1537
|
+
};
|
|
1538
|
+
"min": {
|
|
1539
|
+
"alias": "min";
|
|
1540
|
+
"required": false;
|
|
1541
|
+
"isSignal": true;
|
|
1542
|
+
};
|
|
1543
|
+
"max": {
|
|
1544
|
+
"alias": "max";
|
|
1545
|
+
"required": false;
|
|
1546
|
+
"isSignal": true;
|
|
1547
|
+
};
|
|
1548
|
+
"hour12": {
|
|
1549
|
+
"alias": "hour12";
|
|
1550
|
+
"required": false;
|
|
1551
|
+
"isSignal": true;
|
|
1552
|
+
};
|
|
1553
|
+
"disabled": {
|
|
1554
|
+
"alias": "disabled";
|
|
1555
|
+
"required": false;
|
|
1556
|
+
"isSignal": true;
|
|
1557
|
+
};
|
|
1558
|
+
}, {}, never, never, true, never>;
|
|
1559
|
+
}
|
|
1560
|
+
/**
|
|
1561
|
+
* Navbar 80px — canvas com hairline inferior (Airbnb top-nav).
|
|
1562
|
+
* Slots: [zurNavbarLogo], [zurNavbarLinks], [zurNavbarActions].
|
|
1563
|
+
* Hospeda o <zur-theme-toggle> no slot de ações.
|
|
1564
|
+
*/
|
|
1565
|
+
export declare class ZurNavbar {
|
|
1566
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurNavbar, never>;
|
|
1567
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurNavbar, "zur-navbar", never, {}, {}, never, ["[zurNavbarLogo]", "[zurNavbarLinks]", "[zurNavbarActions]"], true, never>;
|
|
1568
|
+
}
|
|
1569
|
+
/** Painel individual dentro de <zur-tabs>. */
|
|
1570
|
+
export declare class ZurTab {
|
|
1571
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1572
|
+
readonly active: import("@angular/core").WritableSignal<boolean>;
|
|
1573
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTab, never>;
|
|
1574
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTab, "zur-tab", never, {
|
|
1575
|
+
"label": {
|
|
1576
|
+
"alias": "label";
|
|
1577
|
+
"required": true;
|
|
1578
|
+
"isSignal": true;
|
|
1579
|
+
};
|
|
1580
|
+
}, {}, never, ["*"], true, never>;
|
|
1581
|
+
}
|
|
1582
|
+
/** Tabs com sublinhado 2px ink na aba ativa (Airbnb product-tabs). */
|
|
1583
|
+
export declare class ZurTabs {
|
|
1584
|
+
readonly index: import("@angular/core").ModelSignal<number>;
|
|
1585
|
+
protected readonly tabs: import("@angular/core").Signal<readonly ZurTab[]>;
|
|
1586
|
+
constructor();
|
|
1587
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTabs, never>;
|
|
1588
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTabs, "zur-tabs", never, {
|
|
1589
|
+
"index": {
|
|
1590
|
+
"alias": "index";
|
|
1591
|
+
"required": false;
|
|
1592
|
+
"isSignal": true;
|
|
1593
|
+
};
|
|
1594
|
+
}, {
|
|
1595
|
+
"index": "indexChange";
|
|
1596
|
+
}, ["tabs"], ["*"], true, never>;
|
|
1597
|
+
}
|
|
1598
|
+
/** Item clicável dentro de <zur-menu>. */
|
|
1599
|
+
export declare class ZurMenuItem {
|
|
1600
|
+
readonly selected: import("@angular/core").OutputEmitterRef<void>;
|
|
1601
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurMenuItem, never>;
|
|
1602
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurMenuItem, "zur-menu-item", never, {}, {
|
|
1603
|
+
"selected": "selected";
|
|
1604
|
+
}, never, ["*"], true, never>;
|
|
1605
|
+
}
|
|
1606
|
+
/**
|
|
1607
|
+
* Menu dropdown — gatilho via slot [zurMenuTrigger], painel no tier
|
|
1608
|
+
* único de sombra. Fecha ao clicar fora ou pressionar ESC.
|
|
1609
|
+
*/
|
|
1610
|
+
export declare class ZurMenu {
|
|
1611
|
+
private readonly host;
|
|
1612
|
+
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
1613
|
+
toggle(): void;
|
|
1614
|
+
close(): void;
|
|
1615
|
+
protected onDocumentClick(event: MouseEvent): void;
|
|
1616
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurMenu, never>;
|
|
1617
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurMenu, "zur-menu", never, {}, {}, never, ["[zurMenuTrigger]", "*"], true, never>;
|
|
1618
|
+
}
|
|
1619
|
+
export interface ZurBreadcrumbItem {
|
|
1620
|
+
label: string;
|
|
1621
|
+
href?: string;
|
|
1622
|
+
}
|
|
1623
|
+
/** Breadcrumb em caption muted com separador "/". */
|
|
1624
|
+
export declare class ZurBreadcrumb {
|
|
1625
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1626
|
+
readonly items: import("@angular/core").InputSignal<ZurBreadcrumbItem[]>;
|
|
1627
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurBreadcrumb, never>;
|
|
1628
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurBreadcrumb, "zur-breadcrumb", never, {
|
|
1629
|
+
"items": {
|
|
1630
|
+
"alias": "items";
|
|
1631
|
+
"required": false;
|
|
1632
|
+
"isSignal": true;
|
|
1633
|
+
};
|
|
1634
|
+
}, {}, never, never, true, never>;
|
|
1635
|
+
}
|
|
1636
|
+
export type ZurSidenavItemLevel = 'primary' | 'secondary';
|
|
1637
|
+
/**
|
|
1638
|
+
* Navegação lateral do Zuri. Agrupa links (`zur-sidenav-item`) e rótulos de
|
|
1639
|
+
* seção (`zur-sidenav-label`).
|
|
1640
|
+
*
|
|
1641
|
+
* ```html
|
|
1642
|
+
* <zur-sidenav aria-label="Principal">
|
|
1643
|
+
* <a zur-sidenav-item routerLink="/" routerLinkActive="active">Home</a>
|
|
1644
|
+
* </zur-sidenav>
|
|
1645
|
+
* ```
|
|
1646
|
+
*/
|
|
1647
|
+
export declare class ZurSidenav {
|
|
1648
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenav, never>;
|
|
1649
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenav, "zur-sidenav", never, {}, {}, never, ["*"], true, never>;
|
|
1650
|
+
}
|
|
1651
|
+
/**
|
|
1652
|
+
* Item da navegação lateral, aplicado a `<a>` ou `<button>`.
|
|
1653
|
+
* Fica destacado (verde sólido) quando `active` é verdadeiro ou quando o
|
|
1654
|
+
* elemento recebe a classe `active` (ex.: via `routerLinkActive="active"`).
|
|
1655
|
+
*/
|
|
1656
|
+
export declare class ZurSidenavItem {
|
|
1657
|
+
private readonly shell;
|
|
1658
|
+
readonly level: import("@angular/core").InputSignal<ZurSidenavItemLevel>;
|
|
1659
|
+
readonly active: import("@angular/core").InputSignal<boolean>;
|
|
1660
|
+
/** `true` quando a sidebar do layout está recolhida (só ícones). */
|
|
1661
|
+
protected readonly collapsed: import("@angular/core").Signal<boolean>;
|
|
1662
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavItem, never>;
|
|
1663
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavItem, "a[zur-sidenav-item], button[zur-sidenav-item]", never, {
|
|
1664
|
+
"level": {
|
|
1665
|
+
"alias": "level";
|
|
1666
|
+
"required": false;
|
|
1667
|
+
"isSignal": true;
|
|
1668
|
+
};
|
|
1669
|
+
"active": {
|
|
1670
|
+
"alias": "active";
|
|
1671
|
+
"required": false;
|
|
1672
|
+
"isSignal": true;
|
|
1673
|
+
};
|
|
1674
|
+
}, {}, never, ["[zurSidenavIcon]", "*"], true, never>;
|
|
1675
|
+
}
|
|
1676
|
+
/** Rótulo de seção da navegação lateral (caption em caixa alta). */
|
|
1677
|
+
export declare class ZurSidenavLabel {
|
|
606
1678
|
private readonly shell;
|
|
607
1679
|
protected readonly collapsed: import("@angular/core").Signal<boolean>;
|
|
608
1680
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavLabel, never>;
|
|
609
1681
|
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavLabel, "zur-sidenav-label", never, {}, {}, never, ["*"], true, never>;
|
|
610
1682
|
}
|
|
611
|
-
export type ZurTableDensity = 'comfortable' | 'compact';
|
|
612
|
-
export type ZurSortDirection = 'asc' | 'desc';
|
|
613
|
-
export interface ZurSort {
|
|
1683
|
+
export type ZurTableDensity = 'comfortable' | 'compact';
|
|
1684
|
+
export type ZurSortDirection = 'asc' | 'desc';
|
|
1685
|
+
export interface ZurSort {
|
|
1686
|
+
key: string;
|
|
1687
|
+
direction: ZurSortDirection;
|
|
1688
|
+
}
|
|
1689
|
+
/** Texto de filtro de uma coluna (`value` vazio = sem filtro). */
|
|
1690
|
+
export interface ZurColumnFilterChange {
|
|
1691
|
+
key: string;
|
|
1692
|
+
value: string;
|
|
1693
|
+
}
|
|
1694
|
+
/**
|
|
1695
|
+
* Estilo do Zuri para uma `<table>` nativa: cabeçalho em caption, linhas com
|
|
1696
|
+
* hairline, hover e densidade. A ordenação fica com você: marque as colunas com
|
|
1697
|
+
* `zurSortable` e reaja ao `sortChange`.
|
|
1698
|
+
*
|
|
1699
|
+
* ```html
|
|
1700
|
+
* <table zur-table (sortChange)="ordenar($event)">
|
|
1701
|
+
* <thead>
|
|
1702
|
+
* <tr><th zurSortable="nome">Nome</th><th>Produto</th></tr>
|
|
1703
|
+
* </thead>
|
|
1704
|
+
* <tbody>…</tbody>
|
|
1705
|
+
* </table>
|
|
1706
|
+
* ```
|
|
1707
|
+
*/
|
|
1708
|
+
export declare class ZurTable {
|
|
1709
|
+
/** Sem valor, segue a densidade da área (`zurDensity`) ou da página; senão é confortável. */
|
|
1710
|
+
readonly density: import("@angular/core").InputSignal<ZurTableDensity | null>;
|
|
1711
|
+
/** Emite a coluna e a direção sempre que o usuário ordena. */
|
|
1712
|
+
readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
|
|
1713
|
+
readonly sort: import("@angular/core").WritableSignal<ZurSort | null>;
|
|
1714
|
+
/** Ids das linhas selecionadas (two-way). Veja `tr[zurRow]`, `th[zurSelectAll]` e `td[zurSelect]`. */
|
|
1715
|
+
readonly selected: import("@angular/core").ModelSignal<string[]>;
|
|
1716
|
+
/** Emite quando o texto de filtro de uma coluna muda (`zur-column-filter`). */
|
|
1717
|
+
readonly filterChange: import("@angular/core").OutputEmitterRef<ZurColumnFilterChange>;
|
|
1718
|
+
/** Filtros ativos por coluna. */
|
|
1719
|
+
readonly filters: import("@angular/core").WritableSignal<Record<string, string>>;
|
|
1720
|
+
/** Linhas registradas (`tr[zurRow]`), na ordem em que aparecem. */
|
|
1721
|
+
readonly rowIds: import("@angular/core").WritableSignal<string[]>;
|
|
1722
|
+
readonly allSelected: import("@angular/core").Signal<boolean>;
|
|
1723
|
+
readonly someSelected: import("@angular/core").Signal<boolean>;
|
|
1724
|
+
registerRow(id: string): void;
|
|
1725
|
+
unregisterRow(id: string): void;
|
|
1726
|
+
isSelected(id: string): boolean;
|
|
1727
|
+
toggleRow(id: string): void;
|
|
1728
|
+
/** Marca todas as linhas (ou, se já estão todas marcadas, desmarca). */
|
|
1729
|
+
toggleAll(): void;
|
|
1730
|
+
setFilter(key: string, value: string): void;
|
|
1731
|
+
toggleSort(key: string): void;
|
|
1732
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTable, never>;
|
|
1733
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTable, "table[zur-table]", never, {
|
|
1734
|
+
"density": {
|
|
1735
|
+
"alias": "density";
|
|
1736
|
+
"required": false;
|
|
1737
|
+
"isSignal": true;
|
|
1738
|
+
};
|
|
1739
|
+
"selected": {
|
|
1740
|
+
"alias": "selected";
|
|
1741
|
+
"required": false;
|
|
1742
|
+
"isSignal": true;
|
|
1743
|
+
};
|
|
1744
|
+
}, {
|
|
1745
|
+
"sortChange": "sortChange";
|
|
1746
|
+
"selected": "selectedChange";
|
|
1747
|
+
"filterChange": "filterChange";
|
|
1748
|
+
}, never, ["*"], true, never>;
|
|
1749
|
+
}
|
|
1750
|
+
/** Torna um `<th>` ordenável dentro de `table[zur-table]`. O valor é a chave da coluna. */
|
|
1751
|
+
export declare class ZurSortable {
|
|
1752
|
+
protected readonly table: ZurTable;
|
|
1753
|
+
readonly zurSortable: import("@angular/core").InputSignal<string>;
|
|
1754
|
+
protected readonly ariaSort: import("@angular/core").Signal<"none" | "ascending" | "descending">;
|
|
1755
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSortable, never>;
|
|
1756
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSortable, "th[zurSortable]", never, {
|
|
1757
|
+
"zurSortable": {
|
|
1758
|
+
"alias": "zurSortable";
|
|
1759
|
+
"required": true;
|
|
1760
|
+
"isSignal": true;
|
|
1761
|
+
};
|
|
1762
|
+
}, {}, never, ["*", "zur-column-filter"], true, never>;
|
|
1763
|
+
}
|
|
1764
|
+
/**
|
|
1765
|
+
* Linha de dados identificada por `zurRow` (o id usado na seleção). Habilita a seleção por
|
|
1766
|
+
* checkbox, o "marcar todas" e a expansão. Use `#r="zurRow"` para ler `r.expanded()`.
|
|
1767
|
+
*
|
|
1768
|
+
* ```html
|
|
1769
|
+
* <tr [zurRow]="pedido.id" #r="zurRow">
|
|
1770
|
+
* <td zurSelect></td>
|
|
1771
|
+
* <td><button zurExpandToggle></button></td>
|
|
1772
|
+
* <td>{{ pedido.cliente }}</td>
|
|
1773
|
+
* </tr>
|
|
1774
|
+
* @if (r.expanded()) { <tr class="zur-row-detail"><td colspan="3">Detalhes…</td></tr> }
|
|
1775
|
+
* ```
|
|
1776
|
+
*/
|
|
1777
|
+
export declare class ZurTableRow {
|
|
1778
|
+
private readonly table;
|
|
1779
|
+
readonly zurRow: import("@angular/core").InputSignal<string>;
|
|
1780
|
+
readonly expanded: import("@angular/core").ModelSignal<boolean>;
|
|
1781
|
+
readonly selected: import("@angular/core").Signal<boolean>;
|
|
1782
|
+
constructor();
|
|
1783
|
+
toggle(): void;
|
|
1784
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTableRow, never>;
|
|
1785
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurTableRow, "tr[zurRow]", ["zurRow"], {
|
|
1786
|
+
"zurRow": {
|
|
1787
|
+
"alias": "zurRow";
|
|
1788
|
+
"required": true;
|
|
1789
|
+
"isSignal": true;
|
|
1790
|
+
};
|
|
1791
|
+
"expanded": {
|
|
1792
|
+
"alias": "expanded";
|
|
1793
|
+
"required": false;
|
|
1794
|
+
"isSignal": true;
|
|
1795
|
+
};
|
|
1796
|
+
}, {
|
|
1797
|
+
"expanded": "expandedChange";
|
|
1798
|
+
}, never, never, true, never>;
|
|
1799
|
+
}
|
|
1800
|
+
/** Checkbox de seleção da linha, dentro de `tr[zurRow]`. */
|
|
1801
|
+
export declare class ZurRowSelect {
|
|
1802
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1803
|
+
protected readonly table: ZurTable;
|
|
1804
|
+
protected readonly row: ZurTableRow;
|
|
1805
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurRowSelect, never>;
|
|
1806
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurRowSelect, "td[zurSelect]", never, {}, {}, never, never, true, never>;
|
|
1807
|
+
}
|
|
1808
|
+
/** Checkbox "selecionar todas" do cabeçalho, com estado indeterminado. */
|
|
1809
|
+
export declare class ZurSelectAll {
|
|
1810
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1811
|
+
protected readonly table: ZurTable;
|
|
1812
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSelectAll, never>;
|
|
1813
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSelectAll, "th[zurSelectAll]", never, {}, {}, never, never, true, never>;
|
|
1814
|
+
}
|
|
1815
|
+
/** Botão que abre e fecha os detalhes da linha (`tr[zurRow]`). */
|
|
1816
|
+
export declare class ZurExpandToggle {
|
|
1817
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1818
|
+
protected readonly row: ZurTableRow;
|
|
1819
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurExpandToggle, never>;
|
|
1820
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurExpandToggle, "button[zurExpandToggle]", never, {}, {}, never, never, true, never>;
|
|
1821
|
+
}
|
|
1822
|
+
/**
|
|
1823
|
+
* Botão de filtro para o cabeçalho de uma coluna. Abre um painel com um campo de texto e
|
|
1824
|
+
* emite `filterChange` na tabela (depois de uma pausa ao digitar, ou no Enter); filtrar as
|
|
1825
|
+
* linhas é com você. Dentro de uma coluna ordenável, fica ao lado do botão de ordenar.
|
|
1826
|
+
*
|
|
1827
|
+
* ```html
|
|
1828
|
+
* <th zurSortable="cliente">Cliente <zur-column-filter key="cliente" /></th>
|
|
1829
|
+
* ```
|
|
1830
|
+
*/
|
|
1831
|
+
export declare class ZurColumnFilter {
|
|
1832
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1833
|
+
private readonly table;
|
|
1834
|
+
private readonly host;
|
|
1835
|
+
private timer;
|
|
1836
|
+
/** Chave da coluna, a mesma enviada no `filterChange`. */
|
|
1837
|
+
readonly key: import("@angular/core").InputSignal<string>;
|
|
1838
|
+
/** Nome da coluna para leitores de tela; padrão: o texto do cabeçalho. */
|
|
1839
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1840
|
+
/** Pausa (ms) depois da digitação antes de emitir. */
|
|
1841
|
+
readonly debounce: import("@angular/core").InputSignal<number>;
|
|
1842
|
+
/** Texto digitado agora (ainda pode não ter sido emitido). */
|
|
1843
|
+
private readonly draft;
|
|
1844
|
+
protected readonly value: import("@angular/core").Signal<string>;
|
|
1845
|
+
constructor();
|
|
1846
|
+
protected name(): string;
|
|
1847
|
+
protected onInput(event: Event): void;
|
|
1848
|
+
protected flush(): void;
|
|
1849
|
+
protected clear(): void;
|
|
1850
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurColumnFilter, never>;
|
|
1851
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurColumnFilter, "zur-column-filter", never, {
|
|
1852
|
+
"key": {
|
|
1853
|
+
"alias": "key";
|
|
1854
|
+
"required": true;
|
|
1855
|
+
"isSignal": true;
|
|
1856
|
+
};
|
|
1857
|
+
"label": {
|
|
1858
|
+
"alias": "label";
|
|
1859
|
+
"required": false;
|
|
1860
|
+
"isSignal": true;
|
|
1861
|
+
};
|
|
1862
|
+
"debounce": {
|
|
1863
|
+
"alias": "debounce";
|
|
1864
|
+
"required": false;
|
|
1865
|
+
"isSignal": true;
|
|
1866
|
+
};
|
|
1867
|
+
}, {}, never, never, true, never>;
|
|
1868
|
+
}
|
|
1869
|
+
export interface ZurTableColumn {
|
|
614
1870
|
key: string;
|
|
615
|
-
|
|
1871
|
+
label: string;
|
|
616
1872
|
}
|
|
617
1873
|
/**
|
|
618
|
-
*
|
|
619
|
-
*
|
|
620
|
-
*
|
|
1874
|
+
* Menu para mostrar e ocultar colunas da tabela. `visible` (two-way) tem as chaves
|
|
1875
|
+
* das colunas à mostra; renderizar ou não cada coluna é com você. Nunca deixa a tabela
|
|
1876
|
+
* sem nenhuma coluna.
|
|
621
1877
|
*
|
|
622
1878
|
* ```html
|
|
623
|
-
* <
|
|
624
|
-
*
|
|
625
|
-
* <tr><th zurSortable="nome">Nome</th><th>Destino</th></tr>
|
|
626
|
-
* </thead>
|
|
627
|
-
* <tbody>…</tbody>
|
|
628
|
-
* </table>
|
|
1879
|
+
* <zur-column-menu [columns]="colunas" [(visible)]="visiveis" />
|
|
1880
|
+
* <th>…</th> @if (visiveis().includes('produto')) { <th>Produto</th> }
|
|
629
1881
|
* ```
|
|
630
1882
|
*/
|
|
631
|
-
export declare class
|
|
632
|
-
readonly
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
readonly
|
|
636
|
-
|
|
637
|
-
|
|
638
|
-
|
|
639
|
-
|
|
640
|
-
|
|
1883
|
+
export declare class ZurColumnMenu {
|
|
1884
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1885
|
+
readonly columns: import("@angular/core").InputSignal<ZurTableColumn[]>;
|
|
1886
|
+
/** Chaves das colunas visíveis (two-way). */
|
|
1887
|
+
readonly visible: import("@angular/core").ModelSignal<string[]>;
|
|
1888
|
+
private readonly onlyOne;
|
|
1889
|
+
protected isLast(key: string): boolean;
|
|
1890
|
+
protected toggle(key: string, on: boolean): void;
|
|
1891
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurColumnMenu, never>;
|
|
1892
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurColumnMenu, "zur-column-menu", never, {
|
|
1893
|
+
"columns": {
|
|
1894
|
+
"alias": "columns";
|
|
1895
|
+
"required": false;
|
|
1896
|
+
"isSignal": true;
|
|
1897
|
+
};
|
|
1898
|
+
"visible": {
|
|
1899
|
+
"alias": "visible";
|
|
641
1900
|
"required": false;
|
|
642
1901
|
"isSignal": true;
|
|
643
1902
|
};
|
|
644
1903
|
}, {
|
|
645
|
-
"
|
|
646
|
-
}, never,
|
|
1904
|
+
"visible": "visibleChange";
|
|
1905
|
+
}, never, never, true, never>;
|
|
647
1906
|
}
|
|
648
|
-
|
|
649
|
-
export
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
1907
|
+
export type ZurChartType = 'bar' | 'line' | 'area' | 'donut';
|
|
1908
|
+
export interface ZurChartSeries {
|
|
1909
|
+
name: string;
|
|
1910
|
+
values: number[];
|
|
1911
|
+
}
|
|
1912
|
+
/** Cores categóricas em ordem fixa: tokens `--zur-chart-1..6` (nunca cíclicas). */
|
|
1913
|
+
export declare const ZUR_CHART_MAX_SERIES = 6;
|
|
1914
|
+
/** Valores "redondos" para o eixo: 0, 20, 40, 60… em vez de 0, 17, 34… */
|
|
1915
|
+
export declare function zurNiceTicks(max: number, count?: number): number[];
|
|
1916
|
+
/** Retângulo com os cantos de cima arredondados e a base reta (a barra "cresce" da linha de base). */
|
|
1917
|
+
export declare function zurBarPath(x: number, y: number, w: number, h: number, radius: number): string;
|
|
1918
|
+
interface TooltipRow {
|
|
1919
|
+
color: string;
|
|
1920
|
+
name: string;
|
|
1921
|
+
value: string;
|
|
1922
|
+
}
|
|
1923
|
+
/**
|
|
1924
|
+
* Gráfico em SVG, sem dependências: barras (agrupadas ou empilhadas), linhas, áreas e rosca.
|
|
1925
|
+
* As cores vêm dos tokens `--zur-chart-1..6` em ordem fixa (a 1ª é a menta) e acompanham o
|
|
1926
|
+
* tema. Acessível por padrão: legenda sempre que há mais de uma série, tooltip no hover **e**
|
|
1927
|
+
* no foco (←→ andam pelas categorias), tabela alternativa para leitores de tela e animação
|
|
1928
|
+
* que respeita `prefers-reduced-motion`. O eixo horizontal não espelha em RTL (dados não se
|
|
1929
|
+
* invertem) e as setas são físicas.
|
|
1930
|
+
*
|
|
1931
|
+
* ```html
|
|
1932
|
+
* <zur-chart type="bar" label="Vendas por mês" [labels]="meses"
|
|
1933
|
+
* [series]="[{ name: 'Vendas', values: [12, 18, 9] }]" />
|
|
1934
|
+
* ```
|
|
1935
|
+
*/
|
|
1936
|
+
export declare class ZurChart {
|
|
1937
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1938
|
+
private readonly host;
|
|
1939
|
+
readonly type: import("@angular/core").InputSignal<ZurChartType>;
|
|
1940
|
+
readonly series: import("@angular/core").InputSignal<ZurChartSeries[]>;
|
|
1941
|
+
/** Nomes das categorias (eixo X) ou das fatias (rosca). */
|
|
1942
|
+
readonly labels: import("@angular/core").InputSignal<string[]>;
|
|
1943
|
+
/** Nome do gráfico para leitores de tela (e rótulo do centro da rosca). */
|
|
1944
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
1945
|
+
readonly height: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
1946
|
+
/** Barras empilhadas em vez de lado a lado. */
|
|
1947
|
+
readonly stacked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
1948
|
+
/** Como escrever os valores (eixo, tooltip, tabela). Padrão: número no idioma. */
|
|
1949
|
+
readonly valueFormat: import("@angular/core").InputSignal<((value: number) => string) | null>;
|
|
1950
|
+
/** Legenda: `auto` mostra com 2+ séries (e na rosca); uma série só não precisa. */
|
|
1951
|
+
readonly legend: import("@angular/core").InputSignal<"auto" | "show" | "hide">;
|
|
1952
|
+
protected readonly width: import("@angular/core").WritableSignal<number>;
|
|
1953
|
+
protected readonly active: import("@angular/core").WritableSignal<number | null>;
|
|
1954
|
+
private readonly focusedIndex;
|
|
1955
|
+
constructor();
|
|
1956
|
+
private fmt;
|
|
1957
|
+
/** Eixo Y compacto quando passa de 10 mil ("12 mil"), completo antes disso. */
|
|
1958
|
+
private fmtAxis;
|
|
1959
|
+
protected readonly visible: import("@angular/core").Signal<ZurChartSeries[]>;
|
|
1960
|
+
protected readonly showLegend: import("@angular/core").Signal<boolean>;
|
|
1961
|
+
private readonly count;
|
|
1962
|
+
protected readonly tabStop: import("@angular/core").Signal<number>;
|
|
1963
|
+
private categoryName;
|
|
1964
|
+
protected readonly view: import("@angular/core").Signal<{
|
|
1965
|
+
left: number;
|
|
1966
|
+
top: number;
|
|
1967
|
+
bottom: number;
|
|
1968
|
+
cx: number;
|
|
1969
|
+
cy: number;
|
|
1970
|
+
total: string;
|
|
1971
|
+
yTicks: {
|
|
1972
|
+
y: number;
|
|
1973
|
+
text: string;
|
|
1974
|
+
}[];
|
|
1975
|
+
xLabels: {
|
|
1976
|
+
i: number;
|
|
1977
|
+
x: number;
|
|
1978
|
+
text: string;
|
|
1979
|
+
}[];
|
|
1980
|
+
bars: {
|
|
1981
|
+
key: string;
|
|
1982
|
+
cat: number;
|
|
1983
|
+
d: string;
|
|
1984
|
+
color: string;
|
|
1985
|
+
}[];
|
|
1986
|
+
lines: {
|
|
1987
|
+
s: number;
|
|
1988
|
+
d: string;
|
|
1989
|
+
areaD: string;
|
|
1990
|
+
color: string;
|
|
1991
|
+
points: {
|
|
1992
|
+
x: number;
|
|
1993
|
+
y: number;
|
|
1994
|
+
}[];
|
|
1995
|
+
}[];
|
|
1996
|
+
centers: number[];
|
|
1997
|
+
cats: {
|
|
1998
|
+
i: number;
|
|
1999
|
+
x: number;
|
|
2000
|
+
w: number;
|
|
2001
|
+
aria: string;
|
|
2002
|
+
}[];
|
|
2003
|
+
slices: {
|
|
2004
|
+
i: number;
|
|
2005
|
+
d: string;
|
|
2006
|
+
color: string;
|
|
2007
|
+
aria: string;
|
|
2008
|
+
}[];
|
|
2009
|
+
legend: {
|
|
2010
|
+
name: string;
|
|
2011
|
+
color: string;
|
|
2012
|
+
}[];
|
|
2013
|
+
}>;
|
|
2014
|
+
protected readonly tooltip: import("@angular/core").Signal<{
|
|
2015
|
+
title: string;
|
|
2016
|
+
rows: TooltipRow[];
|
|
2017
|
+
x: number;
|
|
2018
|
+
y: number;
|
|
2019
|
+
flip: boolean;
|
|
2020
|
+
} | null>;
|
|
2021
|
+
protected readonly tableRows: import("@angular/core").Signal<{
|
|
2022
|
+
label: string;
|
|
2023
|
+
cells: string[];
|
|
2024
|
+
}[]>;
|
|
2025
|
+
protected activate(i: number): void;
|
|
2026
|
+
protected onLeave(): void;
|
|
2027
|
+
protected onBlur(event: FocusEvent): void;
|
|
2028
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
2029
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChart, never>;
|
|
2030
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChart, "zur-chart", never, {
|
|
2031
|
+
"type": {
|
|
2032
|
+
"alias": "type";
|
|
2033
|
+
"required": false;
|
|
2034
|
+
"isSignal": true;
|
|
2035
|
+
};
|
|
2036
|
+
"series": {
|
|
2037
|
+
"alias": "series";
|
|
2038
|
+
"required": false;
|
|
2039
|
+
"isSignal": true;
|
|
2040
|
+
};
|
|
2041
|
+
"labels": {
|
|
2042
|
+
"alias": "labels";
|
|
2043
|
+
"required": false;
|
|
2044
|
+
"isSignal": true;
|
|
2045
|
+
};
|
|
2046
|
+
"label": {
|
|
2047
|
+
"alias": "label";
|
|
2048
|
+
"required": false;
|
|
2049
|
+
"isSignal": true;
|
|
2050
|
+
};
|
|
2051
|
+
"height": {
|
|
2052
|
+
"alias": "height";
|
|
2053
|
+
"required": false;
|
|
2054
|
+
"isSignal": true;
|
|
2055
|
+
};
|
|
2056
|
+
"stacked": {
|
|
2057
|
+
"alias": "stacked";
|
|
2058
|
+
"required": false;
|
|
2059
|
+
"isSignal": true;
|
|
2060
|
+
};
|
|
2061
|
+
"valueFormat": {
|
|
2062
|
+
"alias": "valueFormat";
|
|
2063
|
+
"required": false;
|
|
2064
|
+
"isSignal": true;
|
|
2065
|
+
};
|
|
2066
|
+
"legend": {
|
|
2067
|
+
"alias": "legend";
|
|
2068
|
+
"required": false;
|
|
2069
|
+
"isSignal": true;
|
|
2070
|
+
};
|
|
2071
|
+
}, {}, never, never, true, never>;
|
|
2072
|
+
}
|
|
2073
|
+
/**
|
|
2074
|
+
* Mini-gráfico de tendência para dentro de cartões e tabelas. Uma linha de 2px sobre um fio
|
|
2075
|
+
* de área (10%), na cor `--zur-chart-N`. Dê um `label` para ser lido ("Vendas dos últimos
|
|
2076
|
+
* 12 dias: de 4 a 19"); sem ele o desenho é decorativo e fica escondido dos leitores de tela.
|
|
2077
|
+
*
|
|
2078
|
+
* ```html
|
|
2079
|
+
* <zur-sparkline label="Vendas dos últimos 12 dias" [values]="[4, 6, 5, 9, 12, 11, 15]" />
|
|
2080
|
+
* ```
|
|
2081
|
+
*/
|
|
2082
|
+
export declare class ZurSparkline {
|
|
2083
|
+
readonly values: import("@angular/core").InputSignal<number[]>;
|
|
2084
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2085
|
+
/** Posição da cor na paleta de gráficos (1 = menta, 2 = azul…). */
|
|
2086
|
+
readonly slot: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2087
|
+
readonly height: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
2088
|
+
protected readonly stroke: import("@angular/core").Signal<string>;
|
|
2089
|
+
protected readonly paths: import("@angular/core").Signal<{
|
|
2090
|
+
line: string;
|
|
2091
|
+
area: string;
|
|
2092
|
+
}>;
|
|
2093
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSparkline, never>;
|
|
2094
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSparkline, "zur-sparkline", never, {
|
|
2095
|
+
"values": {
|
|
2096
|
+
"alias": "values";
|
|
2097
|
+
"required": false;
|
|
2098
|
+
"isSignal": true;
|
|
2099
|
+
};
|
|
2100
|
+
"label": {
|
|
2101
|
+
"alias": "label";
|
|
2102
|
+
"required": false;
|
|
2103
|
+
"isSignal": true;
|
|
2104
|
+
};
|
|
2105
|
+
"slot": {
|
|
2106
|
+
"alias": "slot";
|
|
2107
|
+
"required": false;
|
|
2108
|
+
"isSignal": true;
|
|
2109
|
+
};
|
|
2110
|
+
"height": {
|
|
2111
|
+
"alias": "height";
|
|
2112
|
+
"required": false;
|
|
2113
|
+
"isSignal": true;
|
|
2114
|
+
};
|
|
2115
|
+
}, {}, never, never, true, never>;
|
|
2116
|
+
}
|
|
2117
|
+
/**
|
|
2118
|
+
* Indicador (KPI): rótulo, valor grande e variação em relação a um período. A variação
|
|
2119
|
+
* sempre vem com seta **e** sinal (+/−) e é lida por extenso ("em alta em relação ao período
|
|
2120
|
+
* anterior"): a cor reforça, mas nunca é o único sinal. Se subir é ruim (custo, erros), use
|
|
2121
|
+
* `invert`. Aceita um `zur-sparkline` no slot `[zurStatChart]`.
|
|
2122
|
+
*
|
|
2123
|
+
* ```html
|
|
2124
|
+
* <zur-stat label="Pedidos" value="1.284" [delta]="12.4">
|
|
2125
|
+
* <zur-sparkline zurStatChart label="Pedidos dos últimos 12 dias" [values]="serie" />
|
|
2126
|
+
* </zur-stat>
|
|
2127
|
+
* ```
|
|
2128
|
+
*/
|
|
2129
|
+
export declare class ZurStat {
|
|
2130
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2131
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2132
|
+
readonly value: import("@angular/core").InputSignal<string | number>;
|
|
2133
|
+
/** Variação em %, com sinal (12,4 = +12,4%). `null` esconde. */
|
|
2134
|
+
readonly delta: import("@angular/core").InputSignal<number | null>;
|
|
2135
|
+
/** Quando cair é bom (custo, erros): inverte a cor da variação. */
|
|
2136
|
+
readonly invert: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2137
|
+
/** Período de comparação ("vs. mês anterior"). */
|
|
2138
|
+
readonly deltaLabel: import("@angular/core").InputSignal<string>;
|
|
2139
|
+
protected readonly direction: import("@angular/core").Signal<"up" | "down" | "flat">;
|
|
2140
|
+
protected readonly tone: import("@angular/core").Signal<"flat" | "good" | "bad">;
|
|
2141
|
+
protected readonly formatted: import("@angular/core").Signal<string>;
|
|
2142
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurStat, never>;
|
|
2143
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurStat, "zur-stat", never, {
|
|
2144
|
+
"label": {
|
|
2145
|
+
"alias": "label";
|
|
2146
|
+
"required": true;
|
|
2147
|
+
"isSignal": true;
|
|
2148
|
+
};
|
|
2149
|
+
"value": {
|
|
2150
|
+
"alias": "value";
|
|
657
2151
|
"required": true;
|
|
658
2152
|
"isSignal": true;
|
|
659
2153
|
};
|
|
2154
|
+
"delta": {
|
|
2155
|
+
"alias": "delta";
|
|
2156
|
+
"required": false;
|
|
2157
|
+
"isSignal": true;
|
|
2158
|
+
};
|
|
2159
|
+
"invert": {
|
|
2160
|
+
"alias": "invert";
|
|
2161
|
+
"required": false;
|
|
2162
|
+
"isSignal": true;
|
|
2163
|
+
};
|
|
2164
|
+
"deltaLabel": {
|
|
2165
|
+
"alias": "deltaLabel";
|
|
2166
|
+
"required": false;
|
|
2167
|
+
"isSignal": true;
|
|
2168
|
+
};
|
|
2169
|
+
}, {}, never, ["[zurStatChart]"], true, never>;
|
|
2170
|
+
}
|
|
2171
|
+
export type ZurTimelineStatus = 'neutral' | 'active' | 'success' | 'warning' | 'error' | 'info';
|
|
2172
|
+
/**
|
|
2173
|
+
* Linha do tempo vertical (histórico de pedido, auditoria, feed de atividade). É uma `<ol>`
|
|
2174
|
+
* nativa: cada evento é um `li[zur-timeline-item]` e os grupos por dia usam
|
|
2175
|
+
* `li[zur-timeline-heading]`.
|
|
2176
|
+
*
|
|
2177
|
+
* ```html
|
|
2178
|
+
* <ol zur-timeline label="Histórico do pedido">
|
|
2179
|
+
* <li zur-timeline-heading>Hoje</li>
|
|
2180
|
+
* <li zur-timeline-item title="Saiu para entrega" time="10:42" status="success">
|
|
2181
|
+
* O entregador está a caminho.
|
|
2182
|
+
* </li>
|
|
2183
|
+
* <li zur-timeline-item title="Pedido confirmado" time="09:15">Pagamento aprovado.</li>
|
|
2184
|
+
* </ol>
|
|
2185
|
+
* ```
|
|
2186
|
+
*/
|
|
2187
|
+
export declare class ZurTimeline {
|
|
2188
|
+
/** Nome da lista para leitores de tela. */
|
|
2189
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2190
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTimeline, never>;
|
|
2191
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTimeline, "ol[zur-timeline]", never, {
|
|
2192
|
+
"label": {
|
|
2193
|
+
"alias": "label";
|
|
2194
|
+
"required": false;
|
|
2195
|
+
"isSignal": true;
|
|
2196
|
+
};
|
|
660
2197
|
}, {}, never, ["*"], true, never>;
|
|
661
2198
|
}
|
|
2199
|
+
/** Um evento da linha do tempo. */
|
|
2200
|
+
export declare class ZurTimelineItem {
|
|
2201
|
+
readonly title: import("@angular/core").InputSignal<string>;
|
|
2202
|
+
/** Texto de data/hora já formatado ("10:42", "ontem"). */
|
|
2203
|
+
readonly time: import("@angular/core").InputSignal<string>;
|
|
2204
|
+
/** Valor máquina opcional para o `<time datetime>`. */
|
|
2205
|
+
readonly datetime: import("@angular/core").InputSignal<string>;
|
|
2206
|
+
readonly status: import("@angular/core").InputSignal<ZurTimelineStatus>;
|
|
2207
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTimelineItem, never>;
|
|
2208
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTimelineItem, "li[zur-timeline-item]", never, {
|
|
2209
|
+
"title": {
|
|
2210
|
+
"alias": "title";
|
|
2211
|
+
"required": true;
|
|
2212
|
+
"isSignal": true;
|
|
2213
|
+
};
|
|
2214
|
+
"time": {
|
|
2215
|
+
"alias": "time";
|
|
2216
|
+
"required": false;
|
|
2217
|
+
"isSignal": true;
|
|
2218
|
+
};
|
|
2219
|
+
"datetime": {
|
|
2220
|
+
"alias": "datetime";
|
|
2221
|
+
"required": false;
|
|
2222
|
+
"isSignal": true;
|
|
2223
|
+
};
|
|
2224
|
+
"status": {
|
|
2225
|
+
"alias": "status";
|
|
2226
|
+
"required": false;
|
|
2227
|
+
"isSignal": true;
|
|
2228
|
+
};
|
|
2229
|
+
}, {}, never, ["[zurTimelineIcon]", "*"], true, never>;
|
|
2230
|
+
}
|
|
2231
|
+
export interface ZurTreeNode {
|
|
2232
|
+
id: string;
|
|
2233
|
+
label: string;
|
|
2234
|
+
children?: ZurTreeNode[];
|
|
2235
|
+
disabled?: boolean;
|
|
2236
|
+
}
|
|
2237
|
+
export type ZurTreeSelection = 'none' | 'single' | 'multiple';
|
|
2238
|
+
interface FlatNode {
|
|
2239
|
+
node: ZurTreeNode;
|
|
2240
|
+
level: number;
|
|
2241
|
+
posInSet: number;
|
|
2242
|
+
setSize: number;
|
|
2243
|
+
parentId: string | null;
|
|
2244
|
+
expandable: boolean;
|
|
2245
|
+
expanded: boolean;
|
|
2246
|
+
}
|
|
2247
|
+
/** Template de cada nó: `<ng-template zurTreeNode let-node>…</ng-template>`. */
|
|
2248
|
+
export declare class ZurTreeNodeTemplate {
|
|
2249
|
+
readonly template: TemplateRef<{
|
|
2250
|
+
$implicit: ZurTreeNode;
|
|
2251
|
+
expanded: boolean;
|
|
2252
|
+
}>;
|
|
2253
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTreeNodeTemplate, never>;
|
|
2254
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurTreeNodeTemplate, "ng-template[zurTreeNode]", never, {}, {}, never, never, true, never>;
|
|
2255
|
+
}
|
|
2256
|
+
/**
|
|
2257
|
+
* Árvore expansível (pastas, categorias, estrutura de menu) no padrão ARIA `tree`:
|
|
2258
|
+
* ↑↓ andam pelos nós visíveis, → abre (ou desce ao primeiro filho), ← fecha (ou sobe ao pai;
|
|
2259
|
+
* invertidas em RTL), Home/End, `*` abre os irmãos, Enter/Espaço seleciona e digitar uma letra
|
|
2260
|
+
* pula para o próximo nó que começa com ela.
|
|
2261
|
+
*
|
|
2262
|
+
* ```html
|
|
2263
|
+
* <zur-tree label="Categorias" [nodes]="categorias" selection="single" [(selected)]="escolhida" />
|
|
2264
|
+
* ```
|
|
2265
|
+
*/
|
|
2266
|
+
export declare class ZurTree {
|
|
2267
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2268
|
+
private readonly host;
|
|
2269
|
+
readonly nodes: import("@angular/core").InputSignal<ZurTreeNode[]>;
|
|
2270
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2271
|
+
readonly selection: import("@angular/core").InputSignal<ZurTreeSelection>;
|
|
2272
|
+
/** Ids dos nós selecionados (two-way). */
|
|
2273
|
+
readonly selected: import("@angular/core").ModelSignal<string[]>;
|
|
2274
|
+
/** Ids dos nós abertos (two-way). */
|
|
2275
|
+
readonly expanded: import("@angular/core").ModelSignal<string[]>;
|
|
2276
|
+
/** Abriu ou fechou um nó. */
|
|
2277
|
+
readonly nodeToggle: import("@angular/core").OutputEmitterRef<{
|
|
2278
|
+
node: ZurTreeNode;
|
|
2279
|
+
expanded: boolean;
|
|
2280
|
+
}>;
|
|
2281
|
+
protected readonly nodeTemplate: import("@angular/core").Signal<ZurTreeNodeTemplate | undefined>;
|
|
2282
|
+
protected readonly focused: import("@angular/core").WritableSignal<string | null>;
|
|
2283
|
+
private typeahead;
|
|
2284
|
+
private typeaheadTimer;
|
|
2285
|
+
/** Nós visíveis (os filhos de nós fechados ficam de fora), já "achatados". */
|
|
2286
|
+
protected readonly rows: import("@angular/core").Signal<FlatNode[]>;
|
|
2287
|
+
/** Só um nó está no Tab: o focado, ou o selecionado, ou o primeiro. */
|
|
2288
|
+
protected readonly tabStop: import("@angular/core").Signal<string>;
|
|
2289
|
+
protected isSelected(id: string): boolean;
|
|
2290
|
+
private setOpen;
|
|
2291
|
+
private select;
|
|
2292
|
+
private focusRow;
|
|
2293
|
+
protected onRowClick(event: MouseEvent, row: FlatNode): void;
|
|
2294
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
2295
|
+
/** Digitar letras salta para o próximo nó cujo texto começa com elas. */
|
|
2296
|
+
private jumpTo;
|
|
2297
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTree, never>;
|
|
2298
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTree, "zur-tree", never, {
|
|
2299
|
+
"nodes": {
|
|
2300
|
+
"alias": "nodes";
|
|
2301
|
+
"required": false;
|
|
2302
|
+
"isSignal": true;
|
|
2303
|
+
};
|
|
2304
|
+
"label": {
|
|
2305
|
+
"alias": "label";
|
|
2306
|
+
"required": false;
|
|
2307
|
+
"isSignal": true;
|
|
2308
|
+
};
|
|
2309
|
+
"selection": {
|
|
2310
|
+
"alias": "selection";
|
|
2311
|
+
"required": false;
|
|
2312
|
+
"isSignal": true;
|
|
2313
|
+
};
|
|
2314
|
+
"selected": {
|
|
2315
|
+
"alias": "selected";
|
|
2316
|
+
"required": false;
|
|
2317
|
+
"isSignal": true;
|
|
2318
|
+
};
|
|
2319
|
+
"expanded": {
|
|
2320
|
+
"alias": "expanded";
|
|
2321
|
+
"required": false;
|
|
2322
|
+
"isSignal": true;
|
|
2323
|
+
};
|
|
2324
|
+
}, {
|
|
2325
|
+
"selected": "selectedChange";
|
|
2326
|
+
"expanded": "expandedChange";
|
|
2327
|
+
"nodeToggle": "nodeToggle";
|
|
2328
|
+
}, ["nodeTemplate"], never, true, never>;
|
|
2329
|
+
}
|
|
662
2330
|
type PageItem = number | 'gap';
|
|
663
2331
|
/**
|
|
664
2332
|
* Paginação: anterior, números (com reticências quando são muitos) e próxima.
|
|
@@ -712,7 +2380,7 @@ export declare class ZurPagination {
|
|
|
712
2380
|
*
|
|
713
2381
|
* ```html
|
|
714
2382
|
* <zur-accordion>
|
|
715
|
-
* <zur-accordion-item title="Como
|
|
2383
|
+
* <zur-accordion-item title="Como cuidar da planta?">…</zur-accordion-item>
|
|
716
2384
|
* <zur-accordion-item title="Posso cancelar?">…</zur-accordion-item>
|
|
717
2385
|
* </zur-accordion>
|
|
718
2386
|
* ```
|
|
@@ -761,7 +2429,7 @@ export declare class ZurAccordionItem {
|
|
|
761
2429
|
* buscas sem resultado ou telas que ainda não têm conteúdo.
|
|
762
2430
|
*
|
|
763
2431
|
* ```html
|
|
764
|
-
* <zur-empty-state title="
|
|
2432
|
+
* <zur-empty-state title="Seu carrinho está vazio" description="Quando você adicionar uma planta, ela aparece aqui.">
|
|
765
2433
|
* <svg zurEmptyIcon …></svg>
|
|
766
2434
|
* <button zur-button>Explorar</button>
|
|
767
2435
|
* </zur-empty-state>
|
|
@@ -810,6 +2478,90 @@ export declare class ZurStep {
|
|
|
810
2478
|
};
|
|
811
2479
|
}, {}, never, ["*"], true, never>;
|
|
812
2480
|
}
|
|
2481
|
+
export type ZurStepperOrientation = 'horizontal' | 'vertical';
|
|
2482
|
+
export type ZurStepStatus = 'done' | 'current' | 'upcoming' | 'error';
|
|
2483
|
+
/** Conteúdo de uma etapa do `zur-stepper`; só a etapa atual é mostrada. */
|
|
2484
|
+
export declare class ZurStepperStep {
|
|
2485
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
2486
|
+
readonly description: import("@angular/core").InputSignal<string>;
|
|
2487
|
+
/** Marca a etapa com erro (ex.: validação falhou), qualquer que seja a posição. */
|
|
2488
|
+
readonly error: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2489
|
+
/** Preenchido pelo `zur-stepper`. */
|
|
2490
|
+
readonly active: import("@angular/core").WritableSignal<boolean>;
|
|
2491
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurStepperStep, never>;
|
|
2492
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurStepperStep, "zur-stepper-step", never, {
|
|
2493
|
+
"label": {
|
|
2494
|
+
"alias": "label";
|
|
2495
|
+
"required": true;
|
|
2496
|
+
"isSignal": true;
|
|
2497
|
+
};
|
|
2498
|
+
"description": {
|
|
2499
|
+
"alias": "description";
|
|
2500
|
+
"required": false;
|
|
2501
|
+
"isSignal": true;
|
|
2502
|
+
};
|
|
2503
|
+
"error": {
|
|
2504
|
+
"alias": "error";
|
|
2505
|
+
"required": false;
|
|
2506
|
+
"isSignal": true;
|
|
2507
|
+
};
|
|
2508
|
+
}, {}, never, ["*"], true, never>;
|
|
2509
|
+
}
|
|
2510
|
+
/**
|
|
2511
|
+
* Etapas de um fluxo (cadastro, checkout, wizard). O estado de cada etapa vem da posição:
|
|
2512
|
+
* as anteriores à atual estão concluídas. Com `linear`, só dá para voltar ou ir à etapa
|
|
2513
|
+
* atual pelo cabeçalho — avançar é com `next()`. Setas (←→ ou ↑↓ no vertical, invertidas em
|
|
2514
|
+
* RTL) movem o foco entre etapas; Enter ou Espaço ativa.
|
|
2515
|
+
*
|
|
2516
|
+
* ```html
|
|
2517
|
+
* <zur-stepper #s linear [(index)]="etapa">
|
|
2518
|
+
* <zur-stepper-step label="Endereço">…</zur-stepper-step>
|
|
2519
|
+
* <zur-stepper-step label="Pagamento">…</zur-stepper-step>
|
|
2520
|
+
* </zur-stepper>
|
|
2521
|
+
* <button zur-button (click)="s.next()">Continuar</button>
|
|
2522
|
+
* ```
|
|
2523
|
+
*/
|
|
2524
|
+
export declare class ZurStepper {
|
|
2525
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2526
|
+
private readonly host;
|
|
2527
|
+
readonly index: import("@angular/core").ModelSignal<number>;
|
|
2528
|
+
readonly orientation: import("@angular/core").InputSignal<ZurStepperOrientation>;
|
|
2529
|
+
/** Só deixa ir para etapas já alcançadas; avançar é com `next()`. */
|
|
2530
|
+
readonly linear: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2531
|
+
protected readonly steps: import("@angular/core").Signal<readonly ZurStepperStep[]>;
|
|
2532
|
+
/** Etapa mais distante já alcançada (libera o clique no modo linear). */
|
|
2533
|
+
private readonly reached;
|
|
2534
|
+
constructor();
|
|
2535
|
+
protected status(i: number): ZurStepStatus;
|
|
2536
|
+
/** Estado da etapa em palavras, para leitores de tela ("concluída", "etapa atual"…). */
|
|
2537
|
+
protected statusText(i: number): string;
|
|
2538
|
+
protected canGo(i: number): boolean;
|
|
2539
|
+
go(i: number): void;
|
|
2540
|
+
/** Avança uma etapa. No modo linear é o único jeito de liberar a etapa seguinte. */
|
|
2541
|
+
next(): void;
|
|
2542
|
+
previous(): void;
|
|
2543
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
2544
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurStepper, never>;
|
|
2545
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurStepper, "zur-stepper", never, {
|
|
2546
|
+
"index": {
|
|
2547
|
+
"alias": "index";
|
|
2548
|
+
"required": false;
|
|
2549
|
+
"isSignal": true;
|
|
2550
|
+
};
|
|
2551
|
+
"orientation": {
|
|
2552
|
+
"alias": "orientation";
|
|
2553
|
+
"required": false;
|
|
2554
|
+
"isSignal": true;
|
|
2555
|
+
};
|
|
2556
|
+
"linear": {
|
|
2557
|
+
"alias": "linear";
|
|
2558
|
+
"required": false;
|
|
2559
|
+
"isSignal": true;
|
|
2560
|
+
};
|
|
2561
|
+
}, {
|
|
2562
|
+
"index": "indexChange";
|
|
2563
|
+
}, ["steps"], ["*"], true, never>;
|
|
2564
|
+
}
|
|
813
2565
|
export type ZurViewport = 'mobile' | 'tablet' | 'desktop';
|
|
814
2566
|
/** Breakpoints do Zuri: mobile < 768 ≤ tablet < 1024 ≤ desktop. */
|
|
815
2567
|
export declare const ZUR_BREAKPOINTS: {
|
|
@@ -897,9 +2649,9 @@ export declare class ZurTopbar implements OnInit {
|
|
|
897
2649
|
* Cabeçalho de página: breadcrumb opcional, título, descrição e ações.
|
|
898
2650
|
*
|
|
899
2651
|
* ```html
|
|
900
|
-
* <zur-page-header title="
|
|
2652
|
+
* <zur-page-header title="Pedidos" description="Gerencie os pedidos.">
|
|
901
2653
|
* <zur-breadcrumb [items]="trilha" />
|
|
902
|
-
* <button zurPageHeaderActions zur-button>
|
|
2654
|
+
* <button zurPageHeaderActions zur-button>Novo pedido</button>
|
|
903
2655
|
* </zur-page-header>
|
|
904
2656
|
* ```
|
|
905
2657
|
*/
|
|
@@ -1010,7 +2762,7 @@ export declare class ZurListDetailLayout {
|
|
|
1010
2762
|
*
|
|
1011
2763
|
* ```html
|
|
1012
2764
|
* <zur-form-layout [steps]="['Dados', 'Pagamento', 'Revisão']" [current]="1">
|
|
1013
|
-
* <zur-page-header title="
|
|
2765
|
+
* <zur-page-header title="Novo pedido" />
|
|
1014
2766
|
* <zur-input label="Nome" />
|
|
1015
2767
|
* <div zurLayoutActions><button zur-button>Continuar</button></div>
|
|
1016
2768
|
* </zur-form-layout>
|
|
@@ -1119,14 +2871,20 @@ export declare class ZurErrorLayout {
|
|
|
1119
2871
|
* Fecha por ESC, clique no scrim ou no botão ×.
|
|
1120
2872
|
*
|
|
1121
2873
|
* ```html
|
|
1122
|
-
* <zur-modal [(open)]="aberto" title="Confirmar
|
|
2874
|
+
* <zur-modal [(open)]="aberto" title="Confirmar pedido">…</zur-modal>
|
|
1123
2875
|
* ```
|
|
1124
2876
|
*/
|
|
1125
2877
|
export declare class ZurModal {
|
|
1126
2878
|
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2879
|
+
private readonly doc;
|
|
1127
2880
|
readonly open: import("@angular/core").ModelSignal<boolean>;
|
|
1128
2881
|
readonly title: import("@angular/core").InputSignal<string>;
|
|
2882
|
+
private readonly dialog;
|
|
2883
|
+
private returnFocusTo;
|
|
2884
|
+
constructor();
|
|
1129
2885
|
close(): void;
|
|
2886
|
+
/** Mantém o Tab circulando dentro do diálogo. */
|
|
2887
|
+
protected trapFocus(event: KeyboardEvent): void;
|
|
1130
2888
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurModal, never>;
|
|
1131
2889
|
static ɵcmp: i0.ɵɵComponentDeclaration<ZurModal, "zur-modal", never, {
|
|
1132
2890
|
"open": {
|
|
@@ -1203,7 +2961,46 @@ export declare class ZurAlert {
|
|
|
1203
2961
|
"required": false;
|
|
1204
2962
|
"isSignal": true;
|
|
1205
2963
|
};
|
|
1206
|
-
}, {}, never, ["*"], true, never>;
|
|
2964
|
+
}, {}, never, ["*"], true, never>;
|
|
2965
|
+
}
|
|
2966
|
+
export type ZurBannerKind = 'info' | 'success' | 'warning' | 'error';
|
|
2967
|
+
/**
|
|
2968
|
+
* Faixa de aviso de largura total, para o topo da página ou de uma seção (manutenção,
|
|
2969
|
+
* promoção, erro de conexão). Diferente do `zur-alert`, que é um aviso inline dentro do
|
|
2970
|
+
* conteúdo. Com `dismissible`, mostra o botão de fechar e atualiza `[(open)]`.
|
|
2971
|
+
*
|
|
2972
|
+
* ```html
|
|
2973
|
+
* <zur-banner kind="warning" dismissible [(open)]="aviso">
|
|
2974
|
+
* Manutenção hoje às 22h.
|
|
2975
|
+
* <a zurBannerAction href="#">Saiba mais</a>
|
|
2976
|
+
* </zur-banner>
|
|
2977
|
+
* ```
|
|
2978
|
+
*/
|
|
2979
|
+
export declare class ZurBanner {
|
|
2980
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2981
|
+
readonly kind: import("@angular/core").InputSignal<ZurBannerKind>;
|
|
2982
|
+
readonly dismissible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
2983
|
+
readonly open: import("@angular/core").ModelSignal<boolean>;
|
|
2984
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurBanner, never>;
|
|
2985
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurBanner, "zur-banner", never, {
|
|
2986
|
+
"kind": {
|
|
2987
|
+
"alias": "kind";
|
|
2988
|
+
"required": false;
|
|
2989
|
+
"isSignal": true;
|
|
2990
|
+
};
|
|
2991
|
+
"dismissible": {
|
|
2992
|
+
"alias": "dismissible";
|
|
2993
|
+
"required": false;
|
|
2994
|
+
"isSignal": true;
|
|
2995
|
+
};
|
|
2996
|
+
"open": {
|
|
2997
|
+
"alias": "open";
|
|
2998
|
+
"required": false;
|
|
2999
|
+
"isSignal": true;
|
|
3000
|
+
};
|
|
3001
|
+
}, {
|
|
3002
|
+
"open": "openChange";
|
|
3003
|
+
}, never, ["*", "[zurBannerAction]"], true, never>;
|
|
1207
3004
|
}
|
|
1208
3005
|
export type ZurSpinnerSize = 'sm' | 'md' | 'lg';
|
|
1209
3006
|
/** Anel giratório em menta — 20/32/48px. */
|
|
@@ -1287,7 +3084,8 @@ export declare class ZurProgress {
|
|
|
1287
3084
|
};
|
|
1288
3085
|
}, {}, never, never, true, never>;
|
|
1289
3086
|
}
|
|
1290
|
-
|
|
3087
|
+
/** `start`/`end` seguem a direção de leitura (em RTL trocam de lado); `left`/`right` são físicos. */
|
|
3088
|
+
export type ZurDrawerSide = 'start' | 'end' | 'left' | 'right';
|
|
1291
3089
|
/**
|
|
1292
3090
|
* Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
|
|
1293
3091
|
* formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
|
|
@@ -1388,4 +3186,604 @@ export declare class ZurPopoverTrigger {
|
|
|
1388
3186
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopoverTrigger, never>;
|
|
1389
3187
|
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurPopoverTrigger, "[zurPopoverTrigger]", never, {}, {}, never, never, true, never>;
|
|
1390
3188
|
}
|
|
3189
|
+
export interface ZurDialogOptions {
|
|
3190
|
+
title: string;
|
|
3191
|
+
message?: string;
|
|
3192
|
+
confirmLabel?: string;
|
|
3193
|
+
cancelLabel?: string;
|
|
3194
|
+
/** Ação destrutiva: botão vermelho e foco inicial em "Cancelar". */
|
|
3195
|
+
destructive?: boolean;
|
|
3196
|
+
}
|
|
3197
|
+
/** Caixa de diálogo criada por `ZurDialog`; não é usada diretamente no template. */
|
|
3198
|
+
export declare class ZurDialogComponent {
|
|
3199
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3200
|
+
readonly options: import("@angular/core").InputSignal<ZurDialogOptions>;
|
|
3201
|
+
readonly mode: import("@angular/core").InputSignal<"confirm" | "alert">;
|
|
3202
|
+
readonly result: import("@angular/core").OutputEmitterRef<boolean>;
|
|
3203
|
+
protected readonly id: string;
|
|
3204
|
+
private readonly dialog;
|
|
3205
|
+
private readonly confirmBtn;
|
|
3206
|
+
private readonly cancelBtn;
|
|
3207
|
+
private done;
|
|
3208
|
+
protected readonly safeFirst: import("@angular/core").Signal<boolean>;
|
|
3209
|
+
constructor();
|
|
3210
|
+
protected trap(event: KeyboardEvent): void;
|
|
3211
|
+
protected finish(value: boolean): void;
|
|
3212
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDialogComponent, never>;
|
|
3213
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurDialogComponent, "zur-dialog", never, {
|
|
3214
|
+
"options": {
|
|
3215
|
+
"alias": "options";
|
|
3216
|
+
"required": true;
|
|
3217
|
+
"isSignal": true;
|
|
3218
|
+
};
|
|
3219
|
+
"mode": {
|
|
3220
|
+
"alias": "mode";
|
|
3221
|
+
"required": false;
|
|
3222
|
+
"isSignal": true;
|
|
3223
|
+
};
|
|
3224
|
+
}, {
|
|
3225
|
+
"result": "result";
|
|
3226
|
+
}, never, never, true, never>;
|
|
3227
|
+
}
|
|
3228
|
+
/**
|
|
3229
|
+
* Diálogos de confirmação e aviso sem precisar montar um `zur-modal` em cada tela. O foco
|
|
3230
|
+
* fica preso no diálogo e volta ao elemento anterior ao fechar; Esc e clique fora cancelam.
|
|
3231
|
+
*
|
|
3232
|
+
* ```ts
|
|
3233
|
+
* private dialog = inject(ZurDialog);
|
|
3234
|
+
*
|
|
3235
|
+
* if (await this.dialog.confirm({ title: 'Excluir pedido?', message: 'Não dá para desfazer.',
|
|
3236
|
+
* confirmLabel: 'Excluir', destructive: true })) {
|
|
3237
|
+
* this.excluir();
|
|
3238
|
+
* }
|
|
3239
|
+
* ```
|
|
3240
|
+
*/
|
|
3241
|
+
export declare class ZurDialog {
|
|
3242
|
+
private readonly appRef;
|
|
3243
|
+
private readonly env;
|
|
3244
|
+
private readonly doc;
|
|
3245
|
+
/** Pergunta sim/não. Resolve `true` ao confirmar e `false` ao cancelar (botão, Esc ou fora). */
|
|
3246
|
+
confirm(options: ZurDialogOptions): Promise<boolean>;
|
|
3247
|
+
/** Aviso com um único botão. Resolve quando o usuário fecha. */
|
|
3248
|
+
alert(options: ZurDialogOptions): Promise<void>;
|
|
3249
|
+
private open;
|
|
3250
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurDialog, never>;
|
|
3251
|
+
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
3252
|
+
}
|
|
3253
|
+
/**
|
|
3254
|
+
* Menu de clique direito. Declare o menu uma vez e ligue-o a qualquer elemento com
|
|
3255
|
+
* `[zurContextMenu]`; os itens são `zur-menu-item`.
|
|
3256
|
+
*
|
|
3257
|
+
* ```html
|
|
3258
|
+
* <div [zurContextMenu]="menu">Clique com o botão direito aqui</div>
|
|
3259
|
+
* <zur-context-menu #menu>
|
|
3260
|
+
* <zur-menu-item (selected)="renomear()">Renomear</zur-menu-item>
|
|
3261
|
+
* <zur-menu-item (selected)="excluir()">Excluir</zur-menu-item>
|
|
3262
|
+
* </zur-context-menu>
|
|
3263
|
+
* ```
|
|
3264
|
+
*
|
|
3265
|
+
* Abre com o botão direito, **Shift+F10 / tecla Menu** ou toque longo. ↑↓/Home/End navegam,
|
|
3266
|
+
* Esc fecha e devolve o foco ao elemento de origem.
|
|
3267
|
+
*/
|
|
3268
|
+
export declare class ZurContextMenu {
|
|
3269
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3270
|
+
private readonly doc;
|
|
3271
|
+
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
3272
|
+
protected readonly position: import("@angular/core").WritableSignal<{
|
|
3273
|
+
x: number;
|
|
3274
|
+
y: number;
|
|
3275
|
+
}>;
|
|
3276
|
+
private readonly panel;
|
|
3277
|
+
private origin;
|
|
3278
|
+
private returnFocusTo;
|
|
3279
|
+
constructor();
|
|
3280
|
+
/** Abre o menu nas coordenadas da janela. `origin` recebe o foco de volta ao fechar. */
|
|
3281
|
+
show(x: number, y: number, origin?: HTMLElement | null): void;
|
|
3282
|
+
close(returnFocus?: boolean): void;
|
|
3283
|
+
protected onOutside(event: Event): void;
|
|
3284
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3285
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurContextMenu, never>;
|
|
3286
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurContextMenu, "zur-context-menu", never, {}, {}, never, ["*"], true, never>;
|
|
3287
|
+
}
|
|
3288
|
+
/** Liga um elemento a um `zur-context-menu`: botão direito, Shift+F10, tecla Menu e toque longo. */
|
|
3289
|
+
export declare class ZurContextMenuTrigger {
|
|
3290
|
+
readonly zurContextMenu: import("@angular/core").InputSignal<ZurContextMenu>;
|
|
3291
|
+
private readonly host;
|
|
3292
|
+
private timer;
|
|
3293
|
+
protected onContextMenu(event: MouseEvent): void;
|
|
3294
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3295
|
+
protected onPointerDown(event: PointerEvent): void;
|
|
3296
|
+
protected cancelPress(): void;
|
|
3297
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurContextMenuTrigger, never>;
|
|
3298
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurContextMenuTrigger, "[zurContextMenu]", never, {
|
|
3299
|
+
"zurContextMenu": {
|
|
3300
|
+
"alias": "zurContextMenu";
|
|
3301
|
+
"required": true;
|
|
3302
|
+
"isSignal": true;
|
|
3303
|
+
};
|
|
3304
|
+
}, {}, never, never, true, never>;
|
|
3305
|
+
}
|
|
3306
|
+
/** Um slide do `zur-carousel`; só o slide atual é focável e lido. */
|
|
3307
|
+
export declare class ZurCarouselSlide {
|
|
3308
|
+
private readonly i18n;
|
|
3309
|
+
/** Preenchidos pelo `zur-carousel`. */
|
|
3310
|
+
readonly active: import("@angular/core").WritableSignal<boolean>;
|
|
3311
|
+
readonly position: import("@angular/core").WritableSignal<{
|
|
3312
|
+
n: number;
|
|
3313
|
+
total: number;
|
|
3314
|
+
}>;
|
|
3315
|
+
protected readonly ariaLabel: import("@angular/core").Signal<string>;
|
|
3316
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCarouselSlide, never>;
|
|
3317
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurCarouselSlide, "zur-carousel-slide", never, {}, {}, never, ["*"], true, never>;
|
|
3318
|
+
}
|
|
3319
|
+
/**
|
|
3320
|
+
* Carrossel de slides com setas, indicadores e deslize por toque. Teclado: ←→ trocam o slide
|
|
3321
|
+
* (invertidas em RTL). O `autoplay` (ms) para sozinho ao passar o mouse ou focar, tem botão
|
|
3322
|
+
* de pausa e **fica desligado quando o usuário pede menos movimento**.
|
|
3323
|
+
*
|
|
3324
|
+
* ```html
|
|
3325
|
+
* <zur-carousel label="Destaques" [(index)]="i" [autoplay]="5000" loop>
|
|
3326
|
+
* <zur-carousel-slide>…</zur-carousel-slide>
|
|
3327
|
+
* </zur-carousel>
|
|
3328
|
+
* ```
|
|
3329
|
+
*/
|
|
3330
|
+
export declare class ZurCarousel {
|
|
3331
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3332
|
+
private readonly host;
|
|
3333
|
+
private readonly destroyRef;
|
|
3334
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
3335
|
+
readonly index: import("@angular/core").ModelSignal<number>;
|
|
3336
|
+
/** Volta ao primeiro depois do último (e vice-versa). */
|
|
3337
|
+
readonly loop: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3338
|
+
/** Intervalo da troca automática em ms; `0` desliga. */
|
|
3339
|
+
readonly autoplay: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
3340
|
+
protected readonly slides: import("@angular/core").Signal<readonly ZurCarouselSlide[]>;
|
|
3341
|
+
protected readonly count: import("@angular/core").Signal<number>;
|
|
3342
|
+
protected readonly hovered: import("@angular/core").WritableSignal<boolean>;
|
|
3343
|
+
protected readonly focused: import("@angular/core").WritableSignal<boolean>;
|
|
3344
|
+
protected readonly userPaused: import("@angular/core").WritableSignal<boolean>;
|
|
3345
|
+
private readonly reducedMotion;
|
|
3346
|
+
private readonly rtl;
|
|
3347
|
+
protected dragStart: number | null;
|
|
3348
|
+
protected readonly running: import("@angular/core").Signal<boolean>;
|
|
3349
|
+
protected readonly canPrev: import("@angular/core").Signal<boolean>;
|
|
3350
|
+
protected readonly canNext: import("@angular/core").Signal<boolean>;
|
|
3351
|
+
protected readonly transform: import("@angular/core").Signal<string>;
|
|
3352
|
+
constructor();
|
|
3353
|
+
private syncDirection;
|
|
3354
|
+
private advance;
|
|
3355
|
+
goTo(i: number): void;
|
|
3356
|
+
next(): void;
|
|
3357
|
+
previous(): void;
|
|
3358
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3359
|
+
protected onPointerDown(event: PointerEvent): void;
|
|
3360
|
+
protected onPointerUp(event: PointerEvent): void;
|
|
3361
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCarousel, never>;
|
|
3362
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurCarousel, "zur-carousel", never, {
|
|
3363
|
+
"label": {
|
|
3364
|
+
"alias": "label";
|
|
3365
|
+
"required": false;
|
|
3366
|
+
"isSignal": true;
|
|
3367
|
+
};
|
|
3368
|
+
"index": {
|
|
3369
|
+
"alias": "index";
|
|
3370
|
+
"required": false;
|
|
3371
|
+
"isSignal": true;
|
|
3372
|
+
};
|
|
3373
|
+
"loop": {
|
|
3374
|
+
"alias": "loop";
|
|
3375
|
+
"required": false;
|
|
3376
|
+
"isSignal": true;
|
|
3377
|
+
};
|
|
3378
|
+
"autoplay": {
|
|
3379
|
+
"alias": "autoplay";
|
|
3380
|
+
"required": false;
|
|
3381
|
+
"isSignal": true;
|
|
3382
|
+
};
|
|
3383
|
+
}, {
|
|
3384
|
+
"index": "indexChange";
|
|
3385
|
+
}, ["slides"], ["*"], true, never>;
|
|
3386
|
+
}
|
|
3387
|
+
/**
|
|
3388
|
+
* Contêiner de conversa. A área de mensagens é um `role="log"` que rola sozinha para
|
|
3389
|
+
* o fim quando chega mensagem nova ou o texto cresce (streaming) — a menos que o
|
|
3390
|
+
* usuário tenha subido para ler o histórico. O compositor vai por último.
|
|
3391
|
+
*
|
|
3392
|
+
* ```html
|
|
3393
|
+
* <zur-chat style="height: 480px">
|
|
3394
|
+
* <zur-chat-divider>Hoje</zur-chat-divider>
|
|
3395
|
+
* <zur-chat-message from="them" author="Ana" time="10:02">Oi! Como posso ajudar?</zur-chat-message>
|
|
3396
|
+
* <zur-chat-message from="me" time="10:03">Minha jiboia está amarelando.</zur-chat-message>
|
|
3397
|
+
* <zur-chat-typing name="Ana" />
|
|
3398
|
+
* <zur-chat-composer (send)="enviar($event)" />
|
|
3399
|
+
* </zur-chat>
|
|
3400
|
+
* ```
|
|
3401
|
+
*/
|
|
3402
|
+
export declare class ZurChat {
|
|
3403
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3404
|
+
readonly label: import("@angular/core").InputSignal<string>;
|
|
3405
|
+
private readonly log;
|
|
3406
|
+
private stick;
|
|
3407
|
+
constructor();
|
|
3408
|
+
/** Rola até a última mensagem. */
|
|
3409
|
+
scrollToBottom(): void;
|
|
3410
|
+
protected onScroll(): void;
|
|
3411
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChat, never>;
|
|
3412
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChat, "zur-chat", never, {
|
|
3413
|
+
"label": {
|
|
3414
|
+
"alias": "label";
|
|
3415
|
+
"required": false;
|
|
3416
|
+
"isSignal": true;
|
|
3417
|
+
};
|
|
3418
|
+
}, {}, never, ["*", "zur-chat-composer"], true, never>;
|
|
3419
|
+
}
|
|
3420
|
+
/** Uma mensagem. `continued` agrupa com a anterior do mesmo autor (esconde avatar e nome). */
|
|
3421
|
+
export declare class ZurChatMessage {
|
|
3422
|
+
readonly from: import("@angular/core").InputSignal<"me" | "them">;
|
|
3423
|
+
readonly author: import("@angular/core").InputSignal<string>;
|
|
3424
|
+
readonly avatar: import("@angular/core").InputSignal<string | null>;
|
|
3425
|
+
/** Texto curto de horário, já formatado ("10:42"). */
|
|
3426
|
+
readonly time: import("@angular/core").InputSignal<string>;
|
|
3427
|
+
readonly continued: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3428
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatMessage, never>;
|
|
3429
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatMessage, "zur-chat-message", never, {
|
|
3430
|
+
"from": {
|
|
3431
|
+
"alias": "from";
|
|
3432
|
+
"required": false;
|
|
3433
|
+
"isSignal": true;
|
|
3434
|
+
};
|
|
3435
|
+
"author": {
|
|
3436
|
+
"alias": "author";
|
|
3437
|
+
"required": false;
|
|
3438
|
+
"isSignal": true;
|
|
3439
|
+
};
|
|
3440
|
+
"avatar": {
|
|
3441
|
+
"alias": "avatar";
|
|
3442
|
+
"required": false;
|
|
3443
|
+
"isSignal": true;
|
|
3444
|
+
};
|
|
3445
|
+
"time": {
|
|
3446
|
+
"alias": "time";
|
|
3447
|
+
"required": false;
|
|
3448
|
+
"isSignal": true;
|
|
3449
|
+
};
|
|
3450
|
+
"continued": {
|
|
3451
|
+
"alias": "continued";
|
|
3452
|
+
"required": false;
|
|
3453
|
+
"isSignal": true;
|
|
3454
|
+
};
|
|
3455
|
+
}, {}, never, ["*"], true, never>;
|
|
3456
|
+
}
|
|
3457
|
+
/** Separador de data/assunto entre grupos de mensagens. */
|
|
3458
|
+
export declare class ZurChatDivider {
|
|
3459
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatDivider, never>;
|
|
3460
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatDivider, "zur-chat-divider", never, {}, {}, never, ["*"], true, never>;
|
|
3461
|
+
}
|
|
3462
|
+
/** Indicador "digitando…" com três pontos (parados se o usuário pede menos movimento). */
|
|
3463
|
+
export declare class ZurChatTyping {
|
|
3464
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3465
|
+
readonly name: import("@angular/core").InputSignal<string>;
|
|
3466
|
+
readonly avatar: import("@angular/core").InputSignal<string | null>;
|
|
3467
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatTyping, never>;
|
|
3468
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatTyping, "zur-chat-typing", never, {
|
|
3469
|
+
"name": {
|
|
3470
|
+
"alias": "name";
|
|
3471
|
+
"required": true;
|
|
3472
|
+
"isSignal": true;
|
|
3473
|
+
};
|
|
3474
|
+
"avatar": {
|
|
3475
|
+
"alias": "avatar";
|
|
3476
|
+
"required": false;
|
|
3477
|
+
"isSignal": true;
|
|
3478
|
+
};
|
|
3479
|
+
}, {}, never, never, true, never>;
|
|
3480
|
+
}
|
|
3481
|
+
/**
|
|
3482
|
+
* Campo de envio: cresce com o texto até `maxRows`, Enter envia, Shift+Enter quebra
|
|
3483
|
+
* linha. Com `attach`, mostra o botão de anexo e emite os arquivos escolhidos.
|
|
3484
|
+
*/
|
|
3485
|
+
export declare class ZurChatComposer {
|
|
3486
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3487
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
3488
|
+
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3489
|
+
readonly attach: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3490
|
+
readonly accept: import("@angular/core").InputSignal<string>;
|
|
3491
|
+
/** Linhas máximas antes de rolar. */
|
|
3492
|
+
readonly maxRows: import("@angular/core").InputSignalWithTransform<number, unknown>;
|
|
3493
|
+
readonly send: import("@angular/core").OutputEmitterRef<string>;
|
|
3494
|
+
readonly attached: import("@angular/core").OutputEmitterRef<File[]>;
|
|
3495
|
+
protected readonly text: import("@angular/core").WritableSignal<string>;
|
|
3496
|
+
protected readonly canSend: import("@angular/core").Signal<boolean>;
|
|
3497
|
+
private readonly field;
|
|
3498
|
+
protected onInput(event: Event): void;
|
|
3499
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3500
|
+
submit(): void;
|
|
3501
|
+
protected onFiles(event: Event): void;
|
|
3502
|
+
private resize;
|
|
3503
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurChatComposer, never>;
|
|
3504
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurChatComposer, "zur-chat-composer", never, {
|
|
3505
|
+
"placeholder": {
|
|
3506
|
+
"alias": "placeholder";
|
|
3507
|
+
"required": false;
|
|
3508
|
+
"isSignal": true;
|
|
3509
|
+
};
|
|
3510
|
+
"disabled": {
|
|
3511
|
+
"alias": "disabled";
|
|
3512
|
+
"required": false;
|
|
3513
|
+
"isSignal": true;
|
|
3514
|
+
};
|
|
3515
|
+
"attach": {
|
|
3516
|
+
"alias": "attach";
|
|
3517
|
+
"required": false;
|
|
3518
|
+
"isSignal": true;
|
|
3519
|
+
};
|
|
3520
|
+
"accept": {
|
|
3521
|
+
"alias": "accept";
|
|
3522
|
+
"required": false;
|
|
3523
|
+
"isSignal": true;
|
|
3524
|
+
};
|
|
3525
|
+
"maxRows": {
|
|
3526
|
+
"alias": "maxRows";
|
|
3527
|
+
"required": false;
|
|
3528
|
+
"isSignal": true;
|
|
3529
|
+
};
|
|
3530
|
+
}, {
|
|
3531
|
+
"send": "send";
|
|
3532
|
+
"attached": "attached";
|
|
3533
|
+
}, never, never, true, never>;
|
|
3534
|
+
}
|
|
3535
|
+
export interface ZurCommand {
|
|
3536
|
+
id: string;
|
|
3537
|
+
label: string;
|
|
3538
|
+
/** Título do grupo em que o comando aparece. */
|
|
3539
|
+
group?: string;
|
|
3540
|
+
description?: string;
|
|
3541
|
+
/** Atalho exibido à direita, ex.: `['G', 'P']` ou `['Ctrl', 'N']`. */
|
|
3542
|
+
shortcut?: string[];
|
|
3543
|
+
/** Atributo `d` de um path SVG 24×24 (traço), desenhado como ícone. */
|
|
3544
|
+
icon?: string;
|
|
3545
|
+
/** Termos extras que também acham o comando na busca. */
|
|
3546
|
+
keywords?: string[];
|
|
3547
|
+
}
|
|
3548
|
+
interface ZurCommandGroup {
|
|
3549
|
+
name: string;
|
|
3550
|
+
items: {
|
|
3551
|
+
command: ZurCommand;
|
|
3552
|
+
index: number;
|
|
3553
|
+
}[];
|
|
3554
|
+
}
|
|
3555
|
+
/**
|
|
3556
|
+
* Busca global de páginas e ações (estilo Linear/Raycast). Abre com Ctrl+K / ⌘K
|
|
3557
|
+
* (desligue com `[hotkey]="false"`) ou por `[(open)]`; filtra ignorando acentos e por
|
|
3558
|
+
* iniciais; setas navegam, Enter executa, Esc fecha e devolve o foco.
|
|
3559
|
+
*
|
|
3560
|
+
* ```html
|
|
3561
|
+
* <zur-command-palette [commands]="comandos" (selected)="executar($event)" />
|
|
3562
|
+
* ```
|
|
3563
|
+
*/
|
|
3564
|
+
export declare class ZurCommandPalette {
|
|
3565
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3566
|
+
private readonly doc;
|
|
3567
|
+
readonly commands: import("@angular/core").InputSignal<ZurCommand[]>;
|
|
3568
|
+
readonly open: import("@angular/core").ModelSignal<boolean>;
|
|
3569
|
+
readonly placeholder: import("@angular/core").InputSignal<string>;
|
|
3570
|
+
/** Abre/fecha com Ctrl+K / ⌘K. */
|
|
3571
|
+
readonly hotkey: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
3572
|
+
readonly selected: import("@angular/core").OutputEmitterRef<ZurCommand>;
|
|
3573
|
+
protected readonly listId: string;
|
|
3574
|
+
protected readonly query: import("@angular/core").WritableSignal<string>;
|
|
3575
|
+
protected readonly active: import("@angular/core").WritableSignal<number>;
|
|
3576
|
+
private readonly field;
|
|
3577
|
+
private returnFocus;
|
|
3578
|
+
/** Comandos filtrados, na ordem em que aparecem (agrupados). */
|
|
3579
|
+
protected readonly flat: import("@angular/core").Signal<ZurCommand[]>;
|
|
3580
|
+
protected readonly groups: import("@angular/core").Signal<ZurCommandGroup[]>;
|
|
3581
|
+
constructor();
|
|
3582
|
+
protected optionId(i: number): string;
|
|
3583
|
+
show(): void;
|
|
3584
|
+
close(): void;
|
|
3585
|
+
protected run(command: ZurCommand): void;
|
|
3586
|
+
protected onInput(event: Event): void;
|
|
3587
|
+
protected onDocumentKeydown(event: KeyboardEvent): void;
|
|
3588
|
+
protected onKeydown(event: KeyboardEvent): void;
|
|
3589
|
+
private scrollActiveIntoView;
|
|
3590
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurCommandPalette, never>;
|
|
3591
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurCommandPalette, "zur-command-palette", never, {
|
|
3592
|
+
"commands": {
|
|
3593
|
+
"alias": "commands";
|
|
3594
|
+
"required": false;
|
|
3595
|
+
"isSignal": true;
|
|
3596
|
+
};
|
|
3597
|
+
"open": {
|
|
3598
|
+
"alias": "open";
|
|
3599
|
+
"required": false;
|
|
3600
|
+
"isSignal": true;
|
|
3601
|
+
};
|
|
3602
|
+
"placeholder": {
|
|
3603
|
+
"alias": "placeholder";
|
|
3604
|
+
"required": false;
|
|
3605
|
+
"isSignal": true;
|
|
3606
|
+
};
|
|
3607
|
+
"hotkey": {
|
|
3608
|
+
"alias": "hotkey";
|
|
3609
|
+
"required": false;
|
|
3610
|
+
"isSignal": true;
|
|
3611
|
+
};
|
|
3612
|
+
}, {
|
|
3613
|
+
"open": "openChange";
|
|
3614
|
+
"selected": "selected";
|
|
3615
|
+
}, never, never, true, never>;
|
|
3616
|
+
}
|
|
3617
|
+
export type ZurNotificationKind = 'info' | 'success' | 'warning' | 'error';
|
|
3618
|
+
export interface ZurNotification {
|
|
3619
|
+
id: string;
|
|
3620
|
+
title: string;
|
|
3621
|
+
body?: string;
|
|
3622
|
+
/** Quando aconteceu — decide o grupo (Hoje / Anteriores). */
|
|
3623
|
+
date: Date;
|
|
3624
|
+
/** Texto curto de horário já formatado ("há 5 min", "ontem"). */
|
|
3625
|
+
time?: string;
|
|
3626
|
+
read: boolean;
|
|
3627
|
+
kind?: ZurNotificationKind;
|
|
3628
|
+
}
|
|
3629
|
+
/**
|
|
3630
|
+
* Sino com contador de não lidas que abre um painel com as notificações agrupadas
|
|
3631
|
+
* em Hoje e Anteriores. Os dados vêm de fora: o componente avisa `read` (clique em
|
|
3632
|
+
* um item) e `readAll`, e quem usa atualiza a lista.
|
|
3633
|
+
*
|
|
3634
|
+
* ```html
|
|
3635
|
+
* <zur-notification-center [notifications]="avisos()"
|
|
3636
|
+
* (read)="marcarLida($event)" (readAll)="marcarTodas()" />
|
|
3637
|
+
* ```
|
|
3638
|
+
*/
|
|
3639
|
+
export declare class ZurNotificationCenter {
|
|
3640
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3641
|
+
readonly notifications: import("@angular/core").InputSignal<ZurNotification[]>;
|
|
3642
|
+
readonly placement: import("@angular/core").InputSignal<ZurPopoverPlacement>;
|
|
3643
|
+
readonly open: import("@angular/core").ModelSignal<boolean>;
|
|
3644
|
+
/** Texto abaixo de "Nada por aqui" quando a lista está vazia. */
|
|
3645
|
+
readonly emptyDescription: import("@angular/core").InputSignal<string>;
|
|
3646
|
+
/** Clique em uma notificação (para marcá-la como lida e navegar). */
|
|
3647
|
+
readonly read: import("@angular/core").OutputEmitterRef<ZurNotification>;
|
|
3648
|
+
readonly readAll: import("@angular/core").OutputEmitterRef<void>;
|
|
3649
|
+
protected readonly unread: import("@angular/core").Signal<number>;
|
|
3650
|
+
protected readonly groups: import("@angular/core").Signal<{
|
|
3651
|
+
name: string;
|
|
3652
|
+
items: ZurNotification[];
|
|
3653
|
+
}[]>;
|
|
3654
|
+
protected onItem(item: ZurNotification): void;
|
|
3655
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurNotificationCenter, never>;
|
|
3656
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurNotificationCenter, "zur-notification-center", never, {
|
|
3657
|
+
"notifications": {
|
|
3658
|
+
"alias": "notifications";
|
|
3659
|
+
"required": false;
|
|
3660
|
+
"isSignal": true;
|
|
3661
|
+
};
|
|
3662
|
+
"placement": {
|
|
3663
|
+
"alias": "placement";
|
|
3664
|
+
"required": false;
|
|
3665
|
+
"isSignal": true;
|
|
3666
|
+
};
|
|
3667
|
+
"open": {
|
|
3668
|
+
"alias": "open";
|
|
3669
|
+
"required": false;
|
|
3670
|
+
"isSignal": true;
|
|
3671
|
+
};
|
|
3672
|
+
"emptyDescription": {
|
|
3673
|
+
"alias": "emptyDescription";
|
|
3674
|
+
"required": false;
|
|
3675
|
+
"isSignal": true;
|
|
3676
|
+
};
|
|
3677
|
+
}, {
|
|
3678
|
+
"open": "openChange";
|
|
3679
|
+
"read": "read";
|
|
3680
|
+
"readAll": "readAll";
|
|
3681
|
+
}, never, never, true, never>;
|
|
3682
|
+
}
|
|
3683
|
+
export interface ZurKanbanItem {
|
|
3684
|
+
id: string;
|
|
3685
|
+
title?: string;
|
|
3686
|
+
}
|
|
3687
|
+
export interface ZurKanbanColumn<T extends ZurKanbanItem = ZurKanbanItem> {
|
|
3688
|
+
id: string;
|
|
3689
|
+
title: string;
|
|
3690
|
+
items: T[];
|
|
3691
|
+
}
|
|
3692
|
+
export interface ZurKanbanMove<T extends ZurKanbanItem = ZurKanbanItem> {
|
|
3693
|
+
item: T;
|
|
3694
|
+
from: string;
|
|
3695
|
+
to: string;
|
|
3696
|
+
fromIndex: number;
|
|
3697
|
+
toIndex: number;
|
|
3698
|
+
}
|
|
3699
|
+
/** Template do cartão: `<ng-template zurKanbanCard let-item let-column="column">`. */
|
|
3700
|
+
export declare class ZurKanbanCard {
|
|
3701
|
+
readonly template: TemplateRef<{
|
|
3702
|
+
$implicit: ZurKanbanItem;
|
|
3703
|
+
column: ZurKanbanColumn;
|
|
3704
|
+
}>;
|
|
3705
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurKanbanCard, never>;
|
|
3706
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurKanbanCard, "ng-template[zurKanbanCard]", never, {}, {}, never, never, true, never>;
|
|
3707
|
+
}
|
|
3708
|
+
interface Grab {
|
|
3709
|
+
itemId: string;
|
|
3710
|
+
/** Posição antes do arrasto por teclado, para o Esc desfazer. */
|
|
3711
|
+
origin: {
|
|
3712
|
+
column: string;
|
|
3713
|
+
index: number;
|
|
3714
|
+
};
|
|
3715
|
+
}
|
|
3716
|
+
/** Move um item entre colunas devolvendo um novo array (imutável). */
|
|
3717
|
+
export declare function zurKanbanMove<T extends ZurKanbanItem>(columns: ZurKanbanColumn<T>[], itemId: string, to: string, toIndex: number): {
|
|
3718
|
+
columns: ZurKanbanColumn<T>[];
|
|
3719
|
+
move: ZurKanbanMove<T>;
|
|
3720
|
+
} | null;
|
|
3721
|
+
/**
|
|
3722
|
+
* Quadro de colunas com cartões arrastáveis. Arrasta com mouse/toque (drag and drop
|
|
3723
|
+
* nativo) ou teclado: Espaço pega o cartão, setas movem (↑↓ na coluna, ←→ entre
|
|
3724
|
+
* colunas), Espaço solta e Esc desfaz — cada passo é anunciado a leitores de tela.
|
|
3725
|
+
* `columns` é two-way e `moved` informa cada movimento.
|
|
3726
|
+
*
|
|
3727
|
+
* ```html
|
|
3728
|
+
* <zur-kanban [(columns)]="colunas" (moved)="salvar($event)">
|
|
3729
|
+
* <ng-template zurKanbanCard let-item>{{ item.title }}</ng-template>
|
|
3730
|
+
* </zur-kanban>
|
|
3731
|
+
* ```
|
|
3732
|
+
*/
|
|
3733
|
+
export declare class ZurKanban {
|
|
3734
|
+
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
3735
|
+
private readonly host;
|
|
3736
|
+
readonly columns: import("@angular/core").ModelSignal<ZurKanbanColumn<ZurKanbanItem>[]>;
|
|
3737
|
+
/** Rótulo do botão "adicionar" no pé de cada coluna; vazio esconde o botão. */
|
|
3738
|
+
readonly addLabel: import("@angular/core").InputSignal<string>;
|
|
3739
|
+
/** Texto usado nos anúncios do teclado. Padrão: `title` ou `id` do item. */
|
|
3740
|
+
readonly cardLabel: import("@angular/core").InputSignal<(item: ZurKanbanItem) => string>;
|
|
3741
|
+
readonly moved: import("@angular/core").OutputEmitterRef<ZurKanbanMove<ZurKanbanItem>>;
|
|
3742
|
+
readonly add: import("@angular/core").OutputEmitterRef<string>;
|
|
3743
|
+
protected readonly cardTemplate: import("@angular/core").Signal<ZurKanbanCard | undefined>;
|
|
3744
|
+
protected readonly instructionsId: string;
|
|
3745
|
+
protected readonly dragId: import("@angular/core").WritableSignal<string | null>;
|
|
3746
|
+
protected readonly dropTarget: import("@angular/core").WritableSignal<{
|
|
3747
|
+
column: string;
|
|
3748
|
+
index: number;
|
|
3749
|
+
} | null>;
|
|
3750
|
+
protected readonly grab: import("@angular/core").WritableSignal<Grab | null>;
|
|
3751
|
+
protected readonly announcement: import("@angular/core").WritableSignal<string>;
|
|
3752
|
+
protected labelOf(item: ZurKanbanItem): string;
|
|
3753
|
+
private columnTitle;
|
|
3754
|
+
private locate;
|
|
3755
|
+
/** Aplica o movimento; retorna se algo mudou. */
|
|
3756
|
+
moveItem(itemId: string, to: string, toIndex: number): boolean;
|
|
3757
|
+
protected onDragStart(event: DragEvent, itemId: string): void;
|
|
3758
|
+
protected onDragOver(event: DragEvent, column: string): void;
|
|
3759
|
+
protected onDragLeave(event: DragEvent): void;
|
|
3760
|
+
protected onDrop(event: DragEvent, column: string): void;
|
|
3761
|
+
protected onDragEnd(): void;
|
|
3762
|
+
protected onKeydown(event: KeyboardEvent, item: ZurKanbanItem, column: string): void;
|
|
3763
|
+
/** Soltar ao sair do cartão (Tab) para não deixar um cartão "preso". */
|
|
3764
|
+
protected onBlur(item: ZurKanbanItem): void;
|
|
3765
|
+
private refocus;
|
|
3766
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurKanban, never>;
|
|
3767
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurKanban, "zur-kanban", never, {
|
|
3768
|
+
"columns": {
|
|
3769
|
+
"alias": "columns";
|
|
3770
|
+
"required": false;
|
|
3771
|
+
"isSignal": true;
|
|
3772
|
+
};
|
|
3773
|
+
"addLabel": {
|
|
3774
|
+
"alias": "addLabel";
|
|
3775
|
+
"required": false;
|
|
3776
|
+
"isSignal": true;
|
|
3777
|
+
};
|
|
3778
|
+
"cardLabel": {
|
|
3779
|
+
"alias": "cardLabel";
|
|
3780
|
+
"required": false;
|
|
3781
|
+
"isSignal": true;
|
|
3782
|
+
};
|
|
3783
|
+
}, {
|
|
3784
|
+
"columns": "columnsChange";
|
|
3785
|
+
"moved": "moved";
|
|
3786
|
+
"add": "add";
|
|
3787
|
+
}, ["cardTemplate"], never, true, never>;
|
|
3788
|
+
}
|
|
1391
3789
|
export {};
|