@juau/zuri 0.2.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 +40 -4
- package/fesm2022/juau-zuri.mjs +6815 -1008
- 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 +1564 -128
package/types/juau-zuri.d.ts
CHANGED
|
@@ -87,6 +87,64 @@ export interface ZurI18n {
|
|
|
87
87
|
cardMoved: (card: string, column: string, position: number) => string;
|
|
88
88
|
cardDropped: (card: string, column: string, position: number) => string;
|
|
89
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;
|
|
90
148
|
}
|
|
91
149
|
export declare const ZUR_I18N_PT: ZurI18n;
|
|
92
150
|
export declare const ZUR_I18N_EN: ZurI18n;
|
|
@@ -194,7 +252,53 @@ export declare class ZurLogo {
|
|
|
194
252
|
};
|
|
195
253
|
}, {}, never, never, true, never>;
|
|
196
254
|
}
|
|
197
|
-
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';
|
|
198
302
|
export type ZurButtonSize = 'sm' | 'md' | 'lg';
|
|
199
303
|
/**
|
|
200
304
|
* Botão do Zuri. Aplicado como atributo em <button> ou <a> nativos
|
|
@@ -275,6 +379,50 @@ export declare class ZurAvatar {
|
|
|
275
379
|
};
|
|
276
380
|
}, {}, never, never, true, never>;
|
|
277
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
|
+
}
|
|
278
426
|
/**
|
|
279
427
|
* Campo de texto do Zuri — 56px, label em caption acima,
|
|
280
428
|
* foco com borda 2px ink (sem glow, Airbnb), erro em vermelho semântico.
|
|
@@ -642,8 +790,8 @@ export declare class ZurDatePicker implements ControlValueAccessor {
|
|
|
642
790
|
readonly hint: import("@angular/core").InputSignal<string>;
|
|
643
791
|
readonly error: import("@angular/core").InputSignal<string>;
|
|
644
792
|
readonly mode: import("@angular/core").InputSignal<ZurDatePickerMode>;
|
|
645
|
-
readonly min: import("@angular/core").InputSignal<Date | null>;
|
|
646
|
-
readonly max: import("@angular/core").InputSignal<Date | null>;
|
|
793
|
+
readonly min: import("@angular/core").InputSignal<Date | null | undefined>;
|
|
794
|
+
readonly max: import("@angular/core").InputSignal<Date | null | undefined>;
|
|
647
795
|
readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
|
|
648
796
|
protected readonly id: string;
|
|
649
797
|
readonly open: import("@angular/core").WritableSignal<boolean>;
|
|
@@ -1046,153 +1194,540 @@ export declare class ZurSegmented implements ControlValueAccessor {
|
|
|
1046
1194
|
}, {}, never, never, true, never>;
|
|
1047
1195
|
}
|
|
1048
1196
|
/**
|
|
1049
|
-
*
|
|
1050
|
-
*
|
|
1051
|
-
* Hospeda o <zur-theme-toggle> no slot de ações.
|
|
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.
|
|
1052
1199
|
*/
|
|
1053
|
-
export declare
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
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;
|
|
1059
1211
|
readonly label: import("@angular/core").InputSignal<string>;
|
|
1060
|
-
readonly
|
|
1061
|
-
|
|
1062
|
-
|
|
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, {
|
|
1063
1244
|
"label": {
|
|
1064
1245
|
"alias": "label";
|
|
1065
|
-
"required":
|
|
1246
|
+
"required": false;
|
|
1066
1247
|
"isSignal": true;
|
|
1067
1248
|
};
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
/** Tabs com sublinhado 2px ink na aba ativa (Airbnb product-tabs). */
|
|
1071
|
-
export declare class ZurTabs {
|
|
1072
|
-
readonly index: import("@angular/core").ModelSignal<number>;
|
|
1073
|
-
protected readonly tabs: import("@angular/core").Signal<readonly ZurTab[]>;
|
|
1074
|
-
constructor();
|
|
1075
|
-
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTabs, never>;
|
|
1076
|
-
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTabs, "zur-tabs", never, {
|
|
1077
|
-
"index": {
|
|
1078
|
-
"alias": "index";
|
|
1249
|
+
"placeholder": {
|
|
1250
|
+
"alias": "placeholder";
|
|
1079
1251
|
"required": false;
|
|
1080
1252
|
"isSignal": true;
|
|
1081
1253
|
};
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
}
|
|
1107
|
-
|
|
1108
|
-
|
|
1109
|
-
href?: string;
|
|
1110
|
-
}
|
|
1111
|
-
/** Breadcrumb em caption muted com separador "/". */
|
|
1112
|
-
export declare class ZurBreadcrumb {
|
|
1113
|
-
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
1114
|
-
readonly items: import("@angular/core").InputSignal<ZurBreadcrumbItem[]>;
|
|
1115
|
-
static ɵfac: i0.ɵɵFactoryDeclaration<ZurBreadcrumb, never>;
|
|
1116
|
-
static ɵcmp: i0.ɵɵComponentDeclaration<ZurBreadcrumb, "zur-breadcrumb", never, {
|
|
1117
|
-
"items": {
|
|
1118
|
-
"alias": "items";
|
|
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";
|
|
1119
1281
|
"required": false;
|
|
1120
1282
|
"isSignal": true;
|
|
1121
1283
|
};
|
|
1122
1284
|
}, {}, never, never, true, never>;
|
|
1123
1285
|
}
|
|
1124
|
-
export type ZurSidenavItemLevel = 'primary' | 'secondary';
|
|
1125
1286
|
/**
|
|
1126
|
-
*
|
|
1127
|
-
*
|
|
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).
|
|
1128
1291
|
*
|
|
1129
1292
|
* ```html
|
|
1130
|
-
* <zur-
|
|
1131
|
-
* <a zur-sidenav-item routerLink="/" routerLinkActive="active">Home</a>
|
|
1132
|
-
* </zur-sidenav>
|
|
1293
|
+
* <zur-otp-input label="Código enviado por SMS" [length]="6" (completed)="verificar($event)" />
|
|
1133
1294
|
* ```
|
|
1134
1295
|
*/
|
|
1135
|
-
export declare class
|
|
1136
|
-
|
|
1137
|
-
|
|
1138
|
-
|
|
1139
|
-
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
|
|
1143
|
-
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
readonly
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
protected readonly
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
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";
|
|
1154
1334
|
"required": false;
|
|
1155
1335
|
"isSignal": true;
|
|
1156
1336
|
};
|
|
1157
|
-
"
|
|
1158
|
-
"alias": "
|
|
1337
|
+
"hint": {
|
|
1338
|
+
"alias": "hint";
|
|
1159
1339
|
"required": false;
|
|
1160
1340
|
"isSignal": true;
|
|
1161
1341
|
};
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
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>;
|
|
1176
1370
|
}
|
|
1177
1371
|
/**
|
|
1178
|
-
*
|
|
1179
|
-
*
|
|
1180
|
-
*
|
|
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.
|
|
1181
1375
|
*
|
|
1182
1376
|
* ```html
|
|
1183
|
-
* <
|
|
1184
|
-
*
|
|
1185
|
-
*
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
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 {
|
|
1678
|
+
private readonly shell;
|
|
1679
|
+
protected readonly collapsed: import("@angular/core").Signal<boolean>;
|
|
1680
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<ZurSidenavLabel, never>;
|
|
1681
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<ZurSidenavLabel, "zur-sidenav-label", never, {}, {}, never, ["*"], true, never>;
|
|
1682
|
+
}
|
|
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>
|
|
1189
1706
|
* ```
|
|
1190
1707
|
*/
|
|
1191
1708
|
export declare class ZurTable {
|
|
1192
|
-
|
|
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>;
|
|
1193
1711
|
/** Emite a coluna e a direção sempre que o usuário ordena. */
|
|
1194
1712
|
readonly sortChange: import("@angular/core").OutputEmitterRef<ZurSort>;
|
|
1195
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;
|
|
1196
1731
|
toggleSort(key: string): void;
|
|
1197
1732
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurTable, never>;
|
|
1198
1733
|
static ɵcmp: i0.ɵɵComponentDeclaration<ZurTable, "table[zur-table]", never, {
|
|
@@ -1201,24 +1736,597 @@ export declare class ZurTable {
|
|
|
1201
1736
|
"required": false;
|
|
1202
1737
|
"isSignal": true;
|
|
1203
1738
|
};
|
|
1204
|
-
|
|
1205
|
-
|
|
1206
|
-
|
|
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 {
|
|
1870
|
+
key: string;
|
|
1871
|
+
label: string;
|
|
1872
|
+
}
|
|
1873
|
+
/**
|
|
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.
|
|
1877
|
+
*
|
|
1878
|
+
* ```html
|
|
1879
|
+
* <zur-column-menu [columns]="colunas" [(visible)]="visiveis" />
|
|
1880
|
+
* <th>…</th> @if (visiveis().includes('produto')) { <th>Produto</th> }
|
|
1881
|
+
* ```
|
|
1882
|
+
*/
|
|
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";
|
|
1900
|
+
"required": false;
|
|
1901
|
+
"isSignal": true;
|
|
1902
|
+
};
|
|
1903
|
+
}, {
|
|
1904
|
+
"visible": "visibleChange";
|
|
1905
|
+
}, never, never, true, never>;
|
|
1906
|
+
}
|
|
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>;
|
|
1207
2116
|
}
|
|
1208
|
-
/**
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
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";
|
|
1217
2146
|
"required": true;
|
|
1218
2147
|
"isSignal": true;
|
|
1219
2148
|
};
|
|
2149
|
+
"value": {
|
|
2150
|
+
"alias": "value";
|
|
2151
|
+
"required": true;
|
|
2152
|
+
"isSignal": true;
|
|
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
|
+
};
|
|
1220
2197
|
}, {}, never, ["*"], true, never>;
|
|
1221
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
|
+
}
|
|
1222
2330
|
type PageItem = number | 'gap';
|
|
1223
2331
|
/**
|
|
1224
2332
|
* Paginação: anterior, números (com reticências quando são muitos) e próxima.
|
|
@@ -1370,6 +2478,90 @@ export declare class ZurStep {
|
|
|
1370
2478
|
};
|
|
1371
2479
|
}, {}, never, ["*"], true, never>;
|
|
1372
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
|
+
}
|
|
1373
2565
|
export type ZurViewport = 'mobile' | 'tablet' | 'desktop';
|
|
1374
2566
|
/** Breakpoints do Zuri: mobile < 768 ≤ tablet < 1024 ≤ desktop. */
|
|
1375
2567
|
export declare const ZUR_BREAKPOINTS: {
|
|
@@ -1684,9 +2876,15 @@ export declare class ZurErrorLayout {
|
|
|
1684
2876
|
*/
|
|
1685
2877
|
export declare class ZurModal {
|
|
1686
2878
|
protected readonly i18n: import("@juau/zuri").ZurI18n;
|
|
2879
|
+
private readonly doc;
|
|
1687
2880
|
readonly open: import("@angular/core").ModelSignal<boolean>;
|
|
1688
2881
|
readonly title: import("@angular/core").InputSignal<string>;
|
|
2882
|
+
private readonly dialog;
|
|
2883
|
+
private returnFocusTo;
|
|
2884
|
+
constructor();
|
|
1689
2885
|
close(): void;
|
|
2886
|
+
/** Mantém o Tab circulando dentro do diálogo. */
|
|
2887
|
+
protected trapFocus(event: KeyboardEvent): void;
|
|
1690
2888
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurModal, never>;
|
|
1691
2889
|
static ɵcmp: i0.ɵɵComponentDeclaration<ZurModal, "zur-modal", never, {
|
|
1692
2890
|
"open": {
|
|
@@ -1765,6 +2963,45 @@ export declare class ZurAlert {
|
|
|
1765
2963
|
};
|
|
1766
2964
|
}, {}, never, ["*"], true, never>;
|
|
1767
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>;
|
|
3004
|
+
}
|
|
1768
3005
|
export type ZurSpinnerSize = 'sm' | 'md' | 'lg';
|
|
1769
3006
|
/** Anel giratório em menta — 20/32/48px. */
|
|
1770
3007
|
export declare class ZurSpinner {
|
|
@@ -1847,7 +3084,8 @@ export declare class ZurProgress {
|
|
|
1847
3084
|
};
|
|
1848
3085
|
}, {}, never, never, true, never>;
|
|
1849
3086
|
}
|
|
1850
|
-
|
|
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';
|
|
1851
3089
|
/**
|
|
1852
3090
|
* Painel lateral deslizante (gaveta) sobre a página, para filtros, detalhes ou
|
|
1853
3091
|
* formulários curtos. Fecha com ESC, clique no fundo ou no botão de fechar; o foco
|
|
@@ -1948,6 +3186,204 @@ export declare class ZurPopoverTrigger {
|
|
|
1948
3186
|
static ɵfac: i0.ɵɵFactoryDeclaration<ZurPopoverTrigger, never>;
|
|
1949
3187
|
static ɵdir: i0.ɵɵDirectiveDeclaration<ZurPopoverTrigger, "[zurPopoverTrigger]", never, {}, {}, never, never, true, never>;
|
|
1950
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
|
+
}
|
|
1951
3387
|
/**
|
|
1952
3388
|
* Contêiner de conversa. A área de mensagens é um `role="log"` que rola sozinha para
|
|
1953
3389
|
* o fim quando chega mensagem nova ou o texto cresce (streaming) — a menos que o
|