@exhaustive-ui/mcp 22.0.0-rc.3 → 22.0.1

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.
@@ -10,33 +10,62 @@ Generated: 2026-11-22
10
10
 
11
11
  Setting up ExhaustiveUI in an Angular CLI project.
12
12
 
13
- ## Download
13
+ ## Prerequisites
14
14
 
15
- Prefer to wire things up yourself? Install the packages from the npm registry directly. The next section covers the provider setup that ng add would have written for you.
15
+ ExhaustiveUI v22 targets Angular v22. Any workspace created with the Angular CLI works, standalone or NgModule based.
16
16
 
17
- ## Examples
17
+ - Angular v22, including `@angular/cdk`, `@angular/forms` and `@angular/router`; the form components work with template-driven forms, reactive forms and Signal Forms (`@angular/forms/signals`)
18
+ - RxJS v7.8.1 or newer
19
+ - A package manager of your choice — npm, yarn or pnpm
18
20
 
19
- Every example in this documentation opens in StackBlitz from the code toolbar above each demo, already wired up with the current version. The source repository is the reference for how the library itself is built and consumed.
21
+ Already using PrimeNG? Do not follow this page. The [migration guide](https://exhaustive-ui.com/migration/primeng) covers moving an existing PrimeNG v21 workspace, once updated to Angular v22, across with the
22
+ `migrate-from-primeng` schematic, which is a separate command from the `ng add` below. On Optimus UI v2, follow the [Optimus UI migration guide](https://exhaustive-ui.com/migration/optimus) and its
23
+ `migrate-from-optimus` schematic instead.
20
24
 
21
- ## Icons
25
+ ## Angular Version Compatibility
22
26
 
23
- ExhaustiveUI components accept any icon through templating, so an icon library is optional. That said, every example in this documentation uses the pi pi-{icon} classes from OpenNG Icons , and component defaults such as the DatePicker arrows reference them too. Install it if you want the demos to look the way they do here. Then import the stylesheet, either from your global stylesheet or from the styles array in angular.json .
27
+ Each ExhaustiveUI major targets a single Angular major. Install the version matching your workspace, and see the [update guide](https://exhaustive-ui.com/migration/update) when moving to a newer one.
24
28
 
25
- ## Nextsteps
29
+ ## Install
26
30
 
27
- Once you have ExhaustiveUI up and running, we recommend exploring the following resources to gain a deeper understanding of the library. Global configuration Styled mode and unstyled mode Tailwind CSS integration Pass Through for direct access to the underlying elements Philosophy — what this project promises, and what it does not FAQ
31
+ The recommended way to add ExhaustiveUI to an Angular CLI workspace is a single command.
28
32
 
29
- ## Ngadd
33
+ ```bash
34
+ ng add @exhaustive-ui/core
35
+ ```
30
36
 
31
- The recommended way to add ExhaustiveUI to an Angular CLI workspace is a single command. The schematic asks which theme preset you want and then does the rest: adds @exhaustive-ui/core and @exhaustive-ui/themes to your dependencies wires provideExhaustive into your root providers with the chosen preset, in app.config.ts or your root NgModule installs the packages Pass the preset up front to skip the prompt, or skip the install step if you want to run it yourself: If the schematic cannot find a providers array to update it prints the three manual steps instead of guessing, so nothing in your workspace is rewritten unexpectedly. If it detects an existing primeng dependency it changes nothing and fails with an error rather than reporting success, and points you at the migration guide , which covers the migrate-from-primeng schematic. It does not run that schematic for you. The Angular CLI installs @exhaustive-ui/core before the schematic runs, so the dependency stays in your package.json — the migration schematic needs it there.
37
+ The schematic asks which theme preset you want and then does the rest:
32
38
 
33
- ## Prerequisites
39
+ - adds `@exhaustive-ui/core` and `@exhaustive-ui/themes` to your dependencies
40
+ - wires `provideExhaustive` into your root providers with the chosen preset, in `app.config.ts` or your root NgModule
41
+ - installs the packages
42
+
43
+ Pass the preset up front to skip the prompt, or skip the install step if you want to run it yourself:
44
+
45
+ ```bash
46
+ # Choose the preset without the prompt — Aura, Lara, Material or Nora
47
+ ng add @exhaustive-ui/core --theme=Lara
34
48
 
35
- ExhaustiveUI v22 targets Angular v22. Any workspace created with the Angular CLI works, standalone or NgModule based. Angular v22, including @angular/cdk , @angular/forms and @angular/router ; the form components work with template-driven forms, reactive forms and Signal Forms ( @angular/forms/signals ) RxJS v7.8.1 or newer A package manager of your choice — npm, yarn or pnpm Already using PrimeNG? Do not follow this page. The migration guide covers moving an existing PrimeNG v21 workspace, once updated to Angular v22, across with the migrate-from-primeng schematic, which is a separate command from the ng add below.
49
+ # Wire everything up but do not run the package install
50
+ ng add @exhaustive-ui/core --skip-install
51
+
52
+ # Target a specific project in a multi-project workspace
53
+ ng add @exhaustive-ui/core --project=admin
54
+ ```
55
+
56
+ If the schematic cannot find a providers array to update it prints the three manual steps instead of guessing, so nothing in your workspace is rewritten unexpectedly. If it detects an existing `primeng` or
57
+ `@openng/optimus-ui` dependency it changes nothing and fails with an error rather than reporting success, and points you at the `migrate-from-primeng` or `migrate-from-optimus` schematic, described in the
58
+ [PrimeNG](https://exhaustive-ui.com/migration/primeng) and [Optimus UI](https://exhaustive-ui.com/migration/optimus) migration guides. It does not run that schematic for you. The Angular CLI installs
59
+ `@exhaustive-ui/core` before the schematic runs, so the dependency stays in your `package.json` — the migration schematic needs it there.
60
+
61
+ ## Download
62
+
63
+ Prefer to wire things up yourself? Install the packages from the [npm registry](https://www.npmjs.com/package/@exhaustive-ui/core) directly. The next section covers the provider
64
+ setup that `ng add` would have written for you.
36
65
 
37
66
  ## Provider
38
67
 
39
- Add provideExhaustive to the list of providers in your app.config.ts and use the theme property to configure a theme such as Aura.
68
+ Add `provideExhaustive` to the list of providers in your `app.config.ts` and use the `theme` property to configure a theme such as Aura.
40
69
 
41
70
  ```typescript
42
71
  import { ApplicationConfig } from '@angular/core';
@@ -54,13 +83,41 @@ export const appConfig: ApplicationConfig = {
54
83
  };
55
84
  ```
56
85
 
86
+ ## Icons
87
+
88
+ ExhaustiveUI components accept any icon through templating, so an icon library is optional. That said, every example in this documentation uses the `pi pi-{icon}` classes from
89
+ [OpenNG Icons](https://exhaustive-ui.com/icons), and component defaults such as the DatePicker arrows reference them too. Install it if you want the demos to look the way they do here.
90
+
91
+ ```bash
92
+ npm install @openng/icons
93
+ ```
94
+
95
+ Then import the stylesheet, either from your global stylesheet or from the `styles` array in `angular.json`.
96
+
97
+ ```scss
98
+ @import "@openng/icons/openng-icons.css";
99
+ ```
100
+
57
101
  ## Verify
58
102
 
59
- Verify your setup by adding a component such as Button. Each component can be imported and registered individually so that you only include what you use for bundle optimization. Import path is available in the documentation of the corresponding component.
103
+ Verify your setup by adding a component such as Button. Each component can be imported and registered individually so that you only include what you use for bundle optimization. Import path is available in the documentation of the
104
+ corresponding component.
105
+
106
+ ## Examples
107
+
108
+ Every example in this documentation opens in StackBlitz from the code toolbar above each demo, already wired up with the current version. The
109
+ [source repository](https://github.com/e-xiste/exhaustive-ui) is the reference for how the library itself is built and consumed.
110
+
111
+ ## Next Steps
60
112
 
61
- ## Versioncompatibility
113
+ Once you have ExhaustiveUI up and running, we recommend exploring the following resources to gain a deeper understanding of the library.
62
114
 
63
- Each ExhaustiveUI major targets a single Angular major. Install the version matching your workspace, and see the update guide when moving to a newer one.
115
+ - [Global configuration](https://exhaustive-ui.com/configuration)
116
+ - [Styled mode](https://exhaustive-ui.com/theming/styled) and [unstyled mode](https://exhaustive-ui.com/theming/unstyled)
117
+ - [Tailwind CSS integration](https://exhaustive-ui.com/tailwind)
118
+ - [Pass Through](https://exhaustive-ui.com/passthrough) for direct access to the underlying elements
119
+ - [Philosophy](https://exhaustive-ui.com/philosophy) — what this project promises, and what it does not
120
+ - [FAQ](https://exhaustive-ui.com/faq)
64
121
 
65
122
  ---
66
123
 
@@ -68,21 +125,24 @@ Each ExhaustiveUI major targets a single Angular major. Install the version matc
68
125
 
69
126
  Application wide configuration for ExhaustiveUI.
70
127
 
71
- ## Csp
128
+ ## Provider
72
129
 
73
- The nonce value to use on dynamically generated style elements in core.
130
+ The initial configuration is defined by the `provideExhaustive` provider during application startup.
74
131
 
75
132
  ```typescript
76
- provideExhaustive({
77
- csp: {
78
- nonce: '...'
79
- }
80
- })
133
+ import { ApplicationConfig } from '@angular/core';
134
+ import { provideExhaustive } from '@exhaustive-ui/core/config';
135
+
136
+ export const appConfig: ApplicationConfig = {
137
+ providers: [
138
+ provideExhaustive({ /* options */ })
139
+ ]
140
+ };
81
141
  ```
82
142
 
83
143
  ## Dynamic
84
144
 
85
- Inject the Exhaustive to your application to update the initial configuration at runtime.
145
+ Inject the `Exhaustive` to your application to update the initial configuration at runtime.
86
146
 
87
147
  ```typescript
88
148
  import { Component, OnInit } from '@angular/core';
@@ -102,7 +162,92 @@ export class AppComponent implements OnInit {
102
162
  }
103
163
  ```
104
164
 
105
- ## Filtermode
165
+ ## Theme
166
+
167
+ ExhaustiveUI provides 4 predefined themes out of the box; Aura, Material, Lara and Nora. See the theming documentation for details.
168
+
169
+ ```typescript
170
+ import { ApplicationConfig } from '@angular/core';
171
+ import { provideExhaustive } from '@exhaustive-ui/core/config';
172
+
173
+ import Aura from '@exhaustive-ui/themes/aura';
174
+
175
+ export const appConfig: ApplicationConfig = {
176
+ providers: [
177
+ provideExhaustive({
178
+ theme: {
179
+ preset: Aura,
180
+ options: {
181
+ prefix: 'p',
182
+ darkModeSelector: 'system',
183
+ cssLayer: false
184
+ }
185
+ }
186
+ })
187
+ ]
188
+ };
189
+ ```
190
+
191
+ ## Ripple
192
+
193
+ Ripple is an optional animation for the supported components such as buttons. It is disabled by default.
194
+
195
+ ```typescript
196
+ provideExhaustive({
197
+ ripple: true
198
+ })
199
+ ```
200
+
201
+ ## InputVariant
202
+
203
+ Input fields come in two styles, default is `outlined` with borders around the field whereas `filled` alternative adds a background color to the field. A theme such as Material may add more additional design changes per each
204
+ variant.
205
+
206
+ ## OverlayAppendTo
207
+
208
+ Defines the default location of the overlays; `self` refers to the host element and `body` targets the document body. Defaults to `self`.
209
+
210
+ ## ZIndex
211
+
212
+ ZIndexes are managed automatically to make sure layering of overlay components work seamlessly when combining multiple components. Still there may be cases where you'd like to configure the configure default values such as a custom
213
+ layout where header section is fixed. In a case like this, dropdown needs to be displayed below the application header but a modal dialog should be displayed above. ExhaustiveUI configuration offers the `zIndex` property to
214
+ customize the default values for components categories. Default values are described below and can be customized when setting up ExhaustiveUI.
215
+
216
+ ```typescript
217
+ import { ExhaustiveConfig } from '@exhaustive-ui/core/api';
218
+
219
+ @Component({
220
+ selector: 'app-root',
221
+ templateUrl: './app.component.html'
222
+ })
223
+ export class AppComponent implements OnInit {
224
+
225
+ constructor(private exhaustiveConfig: ExhaustiveConfig) {}
226
+
227
+ ngOnInit() {
228
+ this.exhaustiveConfig.zIndex = {
229
+ modal: 1100, // dialog, sidebar
230
+ overlay: 1000, // dropdown, overlaypanel
231
+ menu: 1000, // overlay menus
232
+ tooltip: 1100 // tooltip
233
+ };
234
+ }
235
+ }
236
+ ```
237
+
238
+ ## Nonce
239
+
240
+ The `nonce` value to use on dynamically generated style elements in core.
241
+
242
+ ```typescript
243
+ provideExhaustive({
244
+ csp: {
245
+ nonce: '...'
246
+ }
247
+ })
248
+ ```
249
+
250
+ ## Filter Mode
106
251
 
107
252
  Default filter modes to display on DataTable filter menus.
108
253
 
@@ -127,23 +272,17 @@ export class AppComponent implements OnInit {
127
272
  }
128
273
  ```
129
274
 
130
- ## Inputvariant
131
-
132
- Input fields come in two styles, default is outlined with borders around the field whereas filled alternative adds a background color to the field. A theme such as Material may add more additional design changes per each variant.
133
-
134
- ## Api
135
-
136
- Locale Options
137
-
138
- ## Repository
275
+ ## Translation
139
276
 
140
- Ready to use settings for locales are available as the @exhaustive-ui/locale package, maintained in the ExhaustiveUI repository. We'd appreciate if you could contribute translations to the repository and share them with the rest of the community.
277
+ A translation is specified using the translation property during initialization.
141
278
 
142
279
  ```typescript
143
- import { de } from '@exhaustive-ui/locale/js/de.js';
144
-
145
280
  provideExhaustive({
146
- translation: de
281
+ translation: {
282
+ accept: 'Aceptar',
283
+ reject: 'Rechazar',
284
+ //translations
285
+ }
147
286
  })
148
287
  ```
149
288
 
@@ -175,146 +314,184 @@ export class AppComponent implements OnInit {
175
314
  }
176
315
  ```
177
316
 
178
- ## Translation
317
+ ## Repository
179
318
 
180
- A translation is specified using the translation property during initialization.
319
+ Ready to use settings for locales are available as the `@exhaustive-ui/locale` package, maintained in the
320
+ [ExhaustiveUI](https://github.com/e-xiste/exhaustive-ui/tree/main/packages/locale) repository. We'd appreciate if you could contribute translations to the repository and share them
321
+ with the rest of the community.
181
322
 
182
323
  ```typescript
324
+ import { de } from '@exhaustive-ui/locale/js/de.js';
325
+
183
326
  provideExhaustive({
184
- translation: {
185
- accept: 'Aceptar',
186
- reject: 'Rechazar',
187
- //translations
188
- }
327
+ translation: de
189
328
  })
190
329
  ```
191
330
 
192
- ## Overlayappendto
331
+ ## API
193
332
 
194
- Defines the default location of the overlays; self refers to the host element and body targets the document body. Defaults to self .
333
+ ### Locale Options
195
334
 
196
- ## Provider
335
+ ---
197
336
 
198
- The initial configuration is defined by the provideExhaustive provider during application startup.
337
+ # Styled Mode
199
338
 
200
- ```typescript
201
- import { ApplicationConfig } from '@angular/core';
202
- import { provideExhaustive } from '@exhaustive-ui/core/config';
339
+ Choose from a variety of pre-styled themes or develop your own.
203
340
 
204
- export const appConfig: ApplicationConfig = {
205
- providers: [
206
- provideExhaustive({ /* options */ })
207
- ]
208
- };
209
- ```
341
+ ## Architecture
210
342
 
211
- ## Ripple
343
+ ExhaustiveUI is a design agnostic library so unlike some other UI libraries it does not enforce a certain styling such as material design. Styling is decoupled from the components using the themes instead. A theme consists of two
344
+ parts;
345
+ `base` and `preset`. The base is the style rules with CSS variables as placeholders whereas the preset is a set of design tokens to feed a base by mapping the tokens to CSS variables. A base may be configured with different
346
+ presets, currently Aura, Material, Lara and Nora are the available built-in options.
212
347
 
213
- Ripple is an optional animation for the supported components such as buttons. It is disabled by default.
348
+ The core of the styled mode architecture is based on a concept named `design token`, a preset defines the token configuration in 3 tiers; `primitive`, `semantic` and `component`.
214
349
 
215
- ```typescript
216
- provideExhaustive({
217
- ripple: true
218
- })
219
- ```
350
+ ### Primitive Tokens
351
+
352
+ Primitive tokens have no context, a color palette is a good example for a primitive token such as `blue-50` to `blue-900`. A token named `blue-500` may be used as the primary color, the background of a message however
353
+ on its own, the name of the token does not indicate context. Usually they are utilized by the semantic tokens.
354
+
355
+ ### Semantic Tokens
356
+
357
+ Semantic tokens define content and their names indicate where they are utilized, a well known example of a semantic token is the `primary.color`. Semantic tokens map to primitive tokens or other semantic tokens. The
358
+ `colorScheme` token group is a special variable to define tokens based on the color scheme active in the application, this allows defining different tokens based on the color scheme like dark mode.
359
+
360
+ ### Component Tokens
361
+
362
+ Component tokens are isolated tokens per component such as `inputtext.background` or `button.color` that map to the semantic tokens. As an example, `button.background` component token maps to the
363
+ `primary.color` semantic token which maps to the `green.500` primitive token.
364
+
365
+ ### Best Practices
366
+
367
+ Use primitive tokens when defining the core color palette and semantic tokens to specify the common design elements such as focus ring, primary colors and surfaces. Components tokens should only be used when customizing a specific
368
+ component. By defining your own design tokens as a custom preset, you'll be able to define your own style without touching CSS. Overriding the ExhaustiveUI components using style classes is not a best practice and should be the last
369
+ resort, design tokens are the suggested approach.
220
370
 
221
371
  ## Theme
222
372
 
223
- ExhaustiveUI provides 4 predefined themes out of the box; Aura, Material, Lara and Nora. See the theming documentation for details.
373
+ The `theme` property is used to customize the initial theme.
224
374
 
225
375
  ```typescript
226
376
  import { ApplicationConfig } from '@angular/core';
227
377
  import { provideExhaustive } from '@exhaustive-ui/core/config';
228
-
229
378
  import Aura from '@exhaustive-ui/themes/aura';
230
379
 
231
380
  export const appConfig: ApplicationConfig = {
232
381
  providers: [
233
382
  provideExhaustive({
234
383
  theme: {
235
- preset: Aura,
236
- options: {
237
- prefix: 'p',
238
- darkModeSelector: 'system',
239
- cssLayer: false
240
- }
384
+ preset: Aura
241
385
  }
242
386
  })
243
387
  ]
244
388
  };
245
389
  ```
246
390
 
247
- ## Zindex
391
+ ## Options
248
392
 
249
- ZIndexes are managed automatically to make sure layering of overlay components work seamlessly when combining multiple components. Still there may be cases where you'd like to configure the configure default values such as a custom layout where header section is fixed. In a case like this, dropdown needs to be displayed below the application header but a modal dialog should be displayed above. ExhaustiveUI configuration offers the zIndex property to customize the default values for components categories. Default values are described below and can be customized when setting up ExhaustiveUI.
393
+ The `options` property defines the how the CSS would be generated from the design tokens of the preset.
250
394
 
251
- ```typescript
252
- import { ExhaustiveConfig } from '@exhaustive-ui/core/api';
395
+ prefix
253
396
 
254
- @Component({
255
- selector: 'app-root',
256
- templateUrl: './app.component.html'
257
- })
258
- export class AppComponent implements OnInit {
397
+ The prefix of the CSS variables, defaults to `p`. For instance, the `primary.color` design token would be `var(--p-primary-color)`.
259
398
 
260
- constructor(private exhaustiveConfig: ExhaustiveConfig) {}
399
+ darkModeSelector
261
400
 
262
- ngOnInit() {
263
- this.exhaustiveConfig.zIndex = {
264
- modal: 1100, // dialog, sidebar
265
- overlay: 1000, // dropdown, overlaypanel
266
- menu: 1000, // overlay menus
267
- tooltip: 1100 // tooltip
268
- };
269
- }
270
- }
271
- ```
401
+ The CSS rule to encapsulate the CSS variables of the dark mode, the default is the `system` to generate `{{ '@' }}media (prefers-color-scheme: dark)`. If you need to make the dark mode toggleable based on the user selection
402
+ define a class selector such as `.app-dark` and toggle this class at the document root. See the dark mode toggle section for an example.
272
403
 
273
- ---
404
+ cssLayer
274
405
 
275
- # Styled Mode
406
+ Defines whether the styles should be defined inside a
407
+ [CSS layer](https://developer.mozilla.org/en-US/docs/Web/CSS/@layer)
408
+ by default or not. A CSS layer would be handy to declare a custom cascade layer for easier customization if necessary. The default is `false`.
276
409
 
277
- Choose from a variety of pre-styled themes or develop your own.
410
+ ## Presets
278
411
 
279
- ## Architecture
412
+ Aura, Material, Lara and Nora are the available built-in options, created to demonstrate the power of the design-agnostic theming. Aura is PrimeTek's own vision, Material follows Google Material Design v2, Lara is based on Bootstrap
413
+ and Nora is inspired by enterprise applications. Visit the [source code](https://github.com/e-xiste/exhaustive-ui/tree/main/packages/themes/src/presets) to learn more about the
414
+ structure of presets. You may use them out of the box with modifications or utilize them as reference in case you need to build your own presets from scratch.
415
+
416
+ ## Colors
280
417
 
281
- ExhaustiveUI is a design agnostic library so unlike some other UI libraries it does not enforce a certain styling such as material design. Styling is decoupled from the components using the themes instead. A theme consists of two parts; base and preset . The base is the style rules with CSS variables as placeholders whereas the preset is a set of design tokens to feed a base by mapping the tokens to CSS variables. A base may be configured with different presets, currently Aura, Material, Lara and Nora are the available built-in options. The core of the styled mode architecture is based on a concept named design token , a preset defines the token configuration in 3 tiers; primitive , semantic and component . Primitive Tokens Primitive tokens have no context, a color palette is a good example for a primitive token such as blue-50 to blue-900 . A token named blue-500 may be used as the primary color, the background of a message however on its own, the name of the token does not indicate context. Usually they are utilized by the semantic tokens. Semantic Tokens Semantic tokens define content and their names indicate where they are utilized, a well known example of a semantic token is the primary.color . Semantic tokens map to primitive tokens or other semantic tokens. The colorScheme token group is a special variable to define tokens based on the color scheme active in the application, this allows defining different tokens based on the color scheme like dark mode. Component Tokens Component tokens are isolated tokens per component such as inputtext.background or button.color that map to the semantic tokens. As an example, button.background component token maps to the primary.color semantic token which maps to the green.500 primitive token. Best Practices Use primitive tokens when defining the core color palette and semantic tokens to specify the common design elements such as focus ring, primary colors and surfaces. Components tokens should only be used when customizing a specific component. By defining your own design tokens as a custom preset, you'll be able to define your own style without touching CSS. Overriding the ExhaustiveUI components using style classes is not a best practice and should be the last resort, design tokens are the suggested approach.
418
+ Color palette of a preset is defined by the `primitive` design token group. You can access colors using CSS variables or the `$dt` utility.
282
419
 
283
- ## Bootstrap
420
+ @for (color of colors; track color) {
421
+ - {{ color }} @for (shade of shades; track shade) { {{ shade }} }
422
+ }
284
423
 
285
- Bootstrap has a reboot utility to reset the CSS of the standard elements. If you are including this utility, you may give it a layer while importing it.
424
+ ## Dark Mode
286
425
 
287
- ## Colors
426
+ ExhaustiveUI uses the `system` as the default `darkModeSelector` in theme configuration. If you have a dark mode switch in your application, set the `darkModeSelector` to the selector you utilize such as
427
+ `.my-app-dark` so that ExhaustiveUI can fit in seamlessly with your color scheme.
428
+
429
+ ```typescript
430
+ provideExhaustive({
431
+ theme: {
432
+ preset: Aura,
433
+ options: {
434
+ darkModeSelector: '.my-app-dark'
435
+ }
436
+ }
437
+ })
438
+ ```
288
439
 
289
- Color palette of a preset is defined by the primitive design token group. You can access colors using CSS variables or the $dt utility. @for (color of colors; track color) { {{ color }} @for (shade of shades; track shade) { {{ shade }} } }
440
+ Following is a very basic example implementation of a dark mode switch, you may extend it further by involving
441
+ `prefers-color-scheme` to retrieve it from the system initially and use `localStorage` to make it stateful. See this
442
+ [article](https://dev.to/abbeyperini/dark-mode-toggle-and-prefers-color-scheme-4f3m)
443
+ for more information.
290
444
 
291
- ## Colorscheme
445
+ In case you prefer to use dark mode all the time, apply the `darkModeSelector` initially and never change it.
292
446
 
293
- A token can be defined per color scheme using light and dark properties of the colorScheme property. Each token can have specific values based on the current color scheme. Common Pitfall When customizing an existing preset, your token overrides may be ignored if you don't properly account for color scheme variations. If the original preset defines a token using the colorScheme property, but your customization only provides a direct value, your override will be ignored because the colorScheme property takes precedence over direct values and the system will continue using the preset's scheme-specific values. When customizing tokens that are not defined with colorScheme in the original preset, your customizations will be applied successfully regardless of how you structure them; whether direct or under colorScheme. Best Practices Check how tokens are defined in the preset before customizing from the source . Always maintain the same structure (direct value or colorScheme) as the original preset. Consider both light and dark mode values when overriding scheme-dependent tokens. This approach ensures your customizations will be applied correctly regardless of the user's selected color scheme.
447
+ It is also possible to disable dark mode completely using `false` or `none` as the value of the selector.
294
448
 
295
- ## Component
449
+ ```typescript
450
+ provideExhaustive({
451
+ theme: {
452
+ preset: Aura,
453
+ options: {
454
+ darkModeSelector: false || 'none'
455
+ }
456
+ }
457
+ })
458
+ ```
296
459
 
297
- The design tokens of a specific component is defined at components layer. Overriding components tokens is not the recommended approach if you are building your own style, building your own preset should be preferred instead. This configuration is global and applies to all card components, in case you need to customize a particular component on a page locally, view the Scoped CSS section for an example.
460
+ ## definePreset
298
461
 
299
- ## Darkmode
462
+ The `definePreset` utility is used to customize an existing preset during the ExhaustiveUI setup. The first parameter is the preset to customize and the second is the design tokens to override.
300
463
 
301
- ExhaustiveUI uses the system as the default darkModeSelector in theme configuration. If you have a dark mode switch in your application, set the darkModeSelector to the selector you utilize such as .my-app-dark so that ExhaustiveUI can fit in seamlessly with your color scheme. Following is a very basic example implementation of a dark mode switch, you may extend it further by involving prefers-color-scheme to retrieve it from the system initially and use localStorage to make it stateful. See this article for more information. In case you prefer to use dark mode all the time, apply the darkModeSelector initially and never change it. It is also possible to disable dark mode completely using false or none as the value of the selector.
464
+ ## Color Scheme
302
465
 
303
- ## Definepreset
466
+ A token can be defined per color scheme using `light` and `dark` properties of the `colorScheme` property. Each token can have specific values based on the current color scheme.
304
467
 
305
- The definePreset utility is used to customize an existing preset during the ExhaustiveUI setup. The first parameter is the preset to customize and the second is the design tokens to override.
468
+ Common Pitfall
306
469
 
307
- ## Dt
470
+ When customizing an existing preset, your token overrides may be ignored if you don't properly account for color scheme variations. If the original preset defines a token using the `colorScheme` property, but your customization
471
+ only provides a direct value, your override will be ignored because the `colorScheme` property takes precedence over direct values and the system will continue using the preset's scheme-specific values. When customizing tokens
472
+ that are not defined with `colorScheme` in the original preset, your customizations will be applied successfully regardless of how you structure them; whether direct or under colorScheme.
308
473
 
309
- The $dt function returns the information about a token like the full path and value. This would be useful if you need to access tokens programmatically.
474
+ Best Practices
310
475
 
311
- ## Extend
476
+ - Check how tokens are defined in the preset before customizing from the [source](https://github.com/e-xiste/exhaustive-ui/blob/main/packages/themes/src/presets).
477
+ - Always maintain the same structure (direct value or colorScheme) as the original preset.
478
+ - Consider both light and dark mode values when overriding scheme-dependent tokens.
479
+
480
+ This approach ensures your customizations will be applied correctly regardless of the user's selected color scheme.
312
481
 
313
- The theming system can be extended by adding custom design tokens and additional styles. This feature provides a high degree of customization, allowing you to adjust styles according to your needs, as you are not limited to the default tokens. The example preset configuration adds a new accent button with custom button.accent.color and button.accent.inverse.color tokens. It is also possible to add tokens globally to share them within the components.
482
+ ## Primary
314
483
 
315
- ## Focusring
484
+ The `primary` defines the main color palette, default value maps to the `emerald` primitive token. Let's setup to use `indigo` instead.
316
485
 
317
- Focus ring defines the outline width, style, color and offset. Let's use a thicker ring with the primary color for the outline.
486
+ ## Surface
487
+
488
+ The color scheme palette that varies between light and dark modes is specified with the surface tokens. Example below uses
489
+ `zinc` for light mode and `slategray` for dark mode. With this setting, light mode, would have a grayscale tone and dark mode would include bluish tone.
490
+
491
+ ## Noir
492
+
493
+ The `noir` mode is the nickname of a variant that uses surface tones as the primary and requires and additional `colorScheme` configuration to implement. A sample preset configuration with black and white variants as the
494
+ primary color;
318
495
 
319
496
  ## Font
320
497
 
@@ -322,105 +499,143 @@ There is no design for fonts as UI components inherit their font settings from t
322
499
 
323
500
  ## Forms
324
501
 
325
- The design tokens of the form input components are derived from the form.field token group. This customization example changes border color to primary on hover. Any component that depends on this semantic token such as dropdown.hover.border.color and textarea.hover.border.color would receive the change.
502
+ The design tokens of the form input components are derived from the `form.field` token group. This customization example changes border color to primary on hover. Any component that depends on this semantic token such as
503
+ `dropdown.hover.border.color` and `textarea.hover.border.color` would receive the change.
326
504
 
327
- ## Libraries
505
+ ## Focus Ring
328
506
 
329
- Example layer configuration for the popular CSS libraries.
507
+ Focus ring defines the outline width, style, color and offset. Let's use a thicker ring with the primary color for the outline.
330
508
 
331
- ## Noir
509
+ ## Component
332
510
 
333
- The noir mode is the nickname of a variant that uses surface tones as the primary and requires and additional colorScheme configuration to implement. A sample preset configuration with black and white variants as the primary color;
511
+ The design tokens of a specific component is defined at `components` layer. Overriding components tokens is not the recommended approach if you are building your own style, building your own preset should be preferred instead.
512
+ This configuration is global and applies to all card components, in case you need to customize a particular component on a page locally, view the Scoped CSS section for an example.
334
513
 
335
- ## Options
514
+ ## Extend
336
515
 
337
- The options property defines the how the CSS would be generated from the design tokens of the preset. prefix The prefix of the CSS variables, defaults to p . For instance, the primary.color design token would be var(--p-primary-color) . darkModeSelector The CSS rule to encapsulate the CSS variables of the dark mode, the default is the system to generate {{ '@' }}media (prefers-color-scheme: dark) . If you need to make the dark mode toggleable based on the user selection define a class selector such as .app-dark and toggle this class at the document root. See the dark mode toggle section for an example. cssLayer Defines whether the styles should be defined inside a CSS layer by default or not. A CSS layer would be handy to declare a custom cascade layer for easier customization if necessary. The default is false .
516
+ The theming system can be extended by adding custom design tokens and additional styles. This feature provides a high degree of customization, allowing you to adjust styles according to your needs, as you are not limited to the
517
+ default tokens.
338
518
 
339
- ## Palette
519
+ The example preset configuration adds a new `accent` button with custom `button.accent.color` and `button.accent.inverse.color` tokens. It is also possible to add tokens globally to share them within the components.
340
520
 
341
- Returns shades and tints of a given color from 50 to 950 as an array.
521
+ ## Scoped Tokens
342
522
 
343
- ## Presets
523
+ Design tokens can be scoped to a certain component using the `dt` property. In this example, first switch uses the global tokens whereas second one overrides the global with its own tokens.
344
524
 
345
- Aura, Material, Lara and Nora are the available built-in options, created to demonstrate the power of the design-agnostic theming. Aura is PrimeTek's own vision, Material follows Google Material Design v2, Lara is based on Bootstrap and Nora is inspired by enterprise applications. Visit the source code to learn more about the structure of presets. You may use them out of the box with modifications or utilize them as reference in case you need to build your own presets from scratch.
525
+ This approach is recommended over the `::ng-deep` as it offers a cleaner API while avoiding the hassle of CSS rule overrides.
346
526
 
347
- ## Primary
527
+ ## usePreset
528
+
529
+ Replaces the current presets entirely, common use case is changing the preset dynamically at runtime.
348
530
 
349
- The primary defines the main color palette, default value maps to the emerald primitive token. Let's setup to use indigo instead.
531
+ ## updatePreset
350
532
 
351
- ## Reset
533
+ Merges the provided tokens to the current preset, an example would be changing the primary color palette dynamically.
352
534
 
353
- In case ExhaustiveUI components have visual issues in your application, a Reset CSS may be the culprit. CSS layers would be an efficient solution that involves enabling the ExhaustiveUI layer, wrapping the Reset CSS in another layer and defining the layer order. This way, your Reset CSS does not get in the way of ExhaustiveUI components.
535
+ ## updatePrimaryPalette
354
536
 
355
- ## Scale
537
+ Updates the primary colors, this is a shorthand to do the same update using `updatePreset`.
356
538
 
357
- ExhaustiveUI UI component use rem units, 1rem equals to the font size of the html element which is 16px by default. Use the root font-size to adjust the size of the components globally. This website uses 14px as the base so it may differ from your application if your base font size is different.
539
+ ## updateSurfacePalette
358
540
 
359
- ## Scopedtokens
541
+ Updates the surface colors, this is a shorthand to do the same update using `updatePreset`.
360
542
 
361
- Design tokens can be scoped to a certain component using the dt property. In this example, first switch uses the global tokens whereas second one overrides the global with its own tokens. This approach is recommended over the ::ng-deep as it offers a cleaner API while avoiding the hassle of CSS rule overrides.
543
+ ## $dt
544
+
545
+ The `$dt` function returns the information about a token like the full path and value. This would be useful if you need to access tokens programmatically.
546
+
547
+ ## palette
548
+
549
+ Returns shades and tints of a given color from 50 to 950 as an array.
362
550
 
363
551
  ## Specificity
364
552
 
365
- The @layer is a standard CSS feature to define cascade layers for a customizable order of precedence. If you need to become more familiar with layers, visit the documentation at MDN to begin with. The cssLayer is disabled by default, when it is enabled at theme configuration, ExhaustiveUI wraps the built-in style classes under the exhaustive cascade layer to make the library styles easy to override. CSS in your app without a layer has the highest CSS specificity, so you'll be able to override styles regardless of the location or how strong a class is written.
553
+ The `@layer` is a standard CSS feature to define cascade layers for a customizable order of precedence. If you need to become more familiar with layers, visit the documentation at
554
+ [MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/@layer) to begin with.
366
555
 
367
- ## Surface
556
+ The `cssLayer` is disabled by default, when it is enabled at theme configuration, ExhaustiveUI wraps the built-in style classes under the `exhaustive` cascade layer to make the library styles easy to override. CSS in your
557
+ app without a layer has the highest CSS specificity, so you'll be able to override styles regardless of the location or how strong a class is written.
368
558
 
369
- The color scheme palette that varies between light and dark modes is specified with the surface tokens. Example below uses zinc for light mode and slategray for dark mode. With this setting, light mode, would have a grayscale tone and dark mode would include bluish tone.
559
+ ## Reset
370
560
 
371
- ## Theme
561
+ In case ExhaustiveUI components have visual issues in your application, a Reset CSS may be the culprit. CSS layers would be an efficient solution that involves enabling the ExhaustiveUI layer, wrapping the Reset CSS in another layer
562
+ and defining the layer order. This way, your Reset CSS does not get in the way of ExhaustiveUI components.
372
563
 
373
- The theme property is used to customize the initial theme.
564
+ ## Scale
374
565
 
375
- ```typescript
376
- import { ApplicationConfig } from '@angular/core';
377
- import { provideExhaustive } from '@exhaustive-ui/core/config';
378
- import Aura from '@exhaustive-ui/themes/aura';
566
+ ExhaustiveUI UI component use `rem` units, 1rem equals to the font size of the `html` element which is `16px` by default. Use the root font-size to adjust the size of the components globally. This website uses
567
+ `14px` as the base so it may differ from your application if your base font size is different.
379
568
 
380
- export const appConfig: ApplicationConfig = {
381
- providers: [
382
- provideExhaustive({
383
- theme: {
384
- preset: Aura
385
- }
386
- })
387
- ]
388
- };
389
- ```
569
+ ## Bootstrap
390
570
 
391
- ## Updatepreset
571
+ Bootstrap has a `reboot` utility to reset the CSS of the standard elements. If you are including this utility, you may give it a layer while importing it.
392
572
 
393
- Merges the provided tokens to the current preset, an example would be changing the primary color palette dynamically.
573
+ ## Libraries
394
574
 
395
- ## Updateprimarypalette
575
+ Example layer configuration for the popular CSS libraries.
396
576
 
397
- Updates the primary colors, this is a shorthand to do the same update using updatePreset .
577
+ ---
398
578
 
399
- ## Updatesurfacepalette
579
+ # Unstyled Mode
400
580
 
401
- Updates the surface colors, this is a shorthand to do the same update using updatePreset .
581
+ Theming ExhaustiveUI with alternative styling approaches.
402
582
 
403
- ## Usepreset
583
+ ## Architecture
404
584
 
405
- Replaces the current presets entirely, common use case is changing the preset dynamically at runtime.
585
+ The term `unstyled` is used to define an alternative styling approach instead of the default theming with design tokens. In unstyled mode the css variables of the design tokens and the css rule sets that utilize them are not
586
+ included. Here is an example of an Unstyled Select, the core functionality and accessibility is provided whereas styling is not included.
406
587
 
407
- ---
588
+ ## Setup
408
589
 
409
- # Unstyled Mode
590
+ Unstyled mode is enabled for the whole suite by enabling `unstyled` option during ExhaustiveUI installation.
410
591
 
411
- Theming ExhaustiveUI with alternative styling approaches.
592
+ ```typescript
593
+ import { ApplicationConfig } from '@angular/core';
412
594
 
413
- ## Architecture
595
+ export const appConfig: ApplicationConfig = {
596
+ providers: [
597
+ provideExhaustive({
598
+ unstyled: true
599
+ })
600
+ ]
601
+ };
602
+ ```
603
+
604
+ Alternatively even in the default styled mode, a particular component can still be used as unstyled by adding the `unstyled` prop of the component.
414
605
 
415
- The term unstyled is used to define an alternative styling approach instead of the default theming with design tokens. In unstyled mode the css variables of the design tokens and the css rule sets that utilize them are not included. Here is an example of an Unstyled Select, the core functionality and accessibility is provided whereas styling is not included.
606
+ ```html
607
+ <div class="card flex justify-center items-center gap-2">
608
+ <p-button label="Styled" icon="pi pi-check" />
609
+ <p-button label="Unstyled" icon="pi pi-check" [unstyled]="true" />
610
+ </div>
611
+ ```
416
612
 
417
613
  ## Example
418
614
 
419
- Unstyled components require styling using your preferred approach. We recommend using Tailwind CSS with PassThrough attributes, a combination that works seamlessly together. The @exhaustive-ui/tailwindcss even provides special variants such as p-outlined: , p-vertical for the ExhaustiveUI components. The example below demonstrates how to style a button component with Tailwind CSS using PassThrough attributes. Before you begin, refer to the pass through section in the button documentation to familiarize yourself with the component's internal structure and PassThrough attributes. In this example, we'll target the root , label and icon elements to apply custom styles.
615
+ Unstyled components require styling using your preferred approach. We recommend using Tailwind CSS with PassThrough attributes, a combination that works seamlessly together. The `@exhaustive-ui/tailwindcss` even provides special
616
+ variants such as `p-outlined:`, `p-vertical` for the ExhaustiveUI components.
617
+
618
+ The example below demonstrates how to style a button component with Tailwind CSS using PassThrough attributes. Before you begin, refer to the
619
+ pass through section in the button documentation to familiarize yourself with the component's internal structure and PassThrough attributes. In this
620
+ example, we'll target the `root`, `label` and `icon` elements to apply custom styles.
621
+
622
+ ```html
623
+ <p-button
624
+ label="Search"
625
+ icon="pi pi-search"
626
+ [unstyled]="true"
627
+ [pt]="{
628
+ root: 'bg-teal-500 hover:bg-teal-700 active:bg-teal-900 cursor-pointer py-2 px-4 rounded-full border-0 flex gap-2',
629
+ label: 'text-white font-bold text-lg',
630
+ icon: 'text-white text-xl!'
631
+ }"
632
+ />
633
+ ```
420
634
 
421
635
  ## Global
422
636
 
423
- A global configuration can be created at application level to avoid repetition via the global pt option so that the styles can be shared from a single location. A particular component can still override a global configuration with its own pt property.
637
+ A global configuration can be created at application level to avoid repetition via the global `pt` option so that the styles can be shared from a single location. A particular component can still override a global configuration
638
+ with its own `pt` property.
424
639
 
425
640
  ```typescript
426
641
  import { ApplicationConfig } from '@angular/core';
@@ -441,23 +656,35 @@ export const appConfig: ApplicationConfig = {
441
656
  };
442
657
  ```
443
658
 
444
- ## Setup
445
-
446
- Unstyled mode is enabled for the whole suite by enabling unstyled option during ExhaustiveUI installation. Alternatively even in the default styled mode, a particular component can still be used as unstyled by adding the unstyled prop of the component.
447
-
448
659
  ---
449
660
 
450
661
  # Icons
451
662
 
452
663
  OpenNG Icons is the default icon library of ExhaustiveUI with over 250 open source icons.
453
664
 
665
+ ## Download
666
+
667
+ The icon library is available at npm, run the following command to download it to your project.
668
+
669
+ ## Import
670
+
671
+ CSS file of the icon library needs to be imported in `styles.scss` of your application.
672
+
454
673
  ## Basic
455
674
 
456
- OpenNG Icons use the pi pi-{icon} syntax such as pi pi-check . A standalone icon can be displayed using an element such as i or span
675
+ OpenNG Icons use the `pi pi-{icon}` syntax such as `pi pi-check`. A standalone icon can be displayed using an element such as `i` or `span`
676
+
677
+ ## Size
678
+
679
+ Size of an icon is controlled with the font-size property of the element.
457
680
 
458
681
  ## Color
459
682
 
460
- Icon color is defined with the color property which is inherited from parent by default.
683
+ Icon color is defined with the `color` property which is inherited from parent by default.
684
+
685
+ ## Spin
686
+
687
+ Special `pi-spin` class applies infinite rotation to an icon.
461
688
 
462
689
  ## Constants
463
690
 
@@ -489,25 +716,10 @@ export class OpenngIconsConstantsDemo {
489
716
  }
490
717
  ```
491
718
 
492
- ## Download
493
-
494
- The icon library is available at npm, run the following command to download it to your project.
495
-
496
- ## Import
497
-
498
- CSS file of the icon library needs to be imported in styles.scss of your application.
499
-
500
719
  ## List
501
720
 
502
- Here is the full list of icons. More icons will be added periodically and you may also request new icons at the issue tracker.
503
-
504
- ## Size
505
-
506
- Size of an icon is controlled with the font-size property of the element.
507
-
508
- ## Spin
509
-
510
- Special pi-spin class applies infinite rotation to an icon.
721
+ Here is the full list of icons. More icons will be added periodically and you may also
722
+ [request new icons](https://github.com/openng-org/icons/issues) at the issue tracker.
511
723
 
512
724
  ---
513
725
 
@@ -515,21 +727,21 @@ Special pi-spin class applies infinite rotation to an icon.
515
727
 
516
728
  Use custom icons with ExhaustiveUI components.
517
729
 
518
- ## Fontawesome
730
+ ## Material
519
731
 
520
- Font Awesome is a popular icon library with a wide range of icons.
732
+ [Material icons](https://fonts.google.com/icons) is the official icon library based on Google Material Design.
521
733
 
522
- ## Image
734
+ ## Font Awesome
523
735
 
524
- Any type of image can be used as an icon.
736
+ [Font Awesome](https://fontawesome.com/) is a popular icon library with a wide range of icons.
525
737
 
526
- ## Material
738
+ ## SVG
527
739
 
528
- Material icons is the official icon library based on Google Material Design.
740
+ Inline SVGs are embedded inside the dom.
529
741
 
530
- ## Svg
742
+ ## Image
531
743
 
532
- Inline SVGs are embedded inside the dom.
744
+ Any type of image can be used as an icon.
533
745
 
534
746
  ---
535
747
 
@@ -539,31 +751,120 @@ Pass Through Props allow direct access to the underlying elements for complete c
539
751
 
540
752
  ## Basic
541
753
 
542
- Each component has a special pt property to define an object with keys corresponding to the available DOM elements. Each value can either be a string, an object or a function that returns a string or an object to define the arbitrary properties to apply to the element such as styling, aria, data-* or custom attributes. If the value is a string or a function that returns a string, it is considered as a class definition and added to the class attribute of the element. Every component documentation has a dedicated section to document the available section names exposed via PT.
754
+ Each component has a special `pt` property to define an object with keys corresponding to the available DOM elements. Each value can either be a string, an object or a function that returns a string or an object to define the
755
+ arbitrary properties to apply to the element such as styling, aria, data-* or custom attributes. If the value is a string or a function that returns a string, it is considered as a class definition and added to the class attribute of
756
+ the element. Every component documentation has a dedicated section to document the available section names exposed via PT.
543
757
 
544
758
  ## Global
545
759
 
546
- PassThrough object can also be defined at a global level to apply all components in an application using the provideExhaustive provider. For example, with the configuration here all panel headers have the bg-primary style class and all autocomplete components have a fixed width. These settings can be overridden by a particular component as components pt property has higher precedence over global pt by default.
760
+ PassThrough object can also be defined at a global level to apply all components in an application using the `provideExhaustive` provider. For example, with the configuration here all panel headers have the
761
+ `bg-primary` style class and all autocomplete components have a fixed width. These settings can be overridden by a particular component as components `pt` property has higher precedence over global `pt` by default.
547
762
 
548
763
  ## Instance
549
764
 
550
- In cases where you need to access the UI Component instance, define a component passthrough type that exposes the component instance or a function that receives a PassThroughContext as parameter.
765
+ In cases where you need to access the UI Component instance, define a component passthrough type that exposes the component instance or a function that receives a `PassThroughContext` as parameter.
551
766
 
552
767
  ## Introduction
553
768
 
554
- In traditional 3rd party UI libraries, users are limited to the API provided by component author. This API commonly consists of inputs, outputs, and content projection. Whenever a requirement emerges for a new customization option in the API, the component author needs to develop and publish it with a new release. The pass through feature is a key element to implement this vision by exposing the component internals in order to apply arbitrary attributes and listeners to the DOM elements. The primary advantage of this approach is that it frees you from being restricted by the main component API. We recommend considering the pass-through feature whenever you need to tailor a component that lacks a built-in feature for your specific requirement. Each component has a special pt property to define an object with keys corresponding to the available DOM elements. A value of a key can either be a string, an object or a function to define the arbitrary properties such as styling, aria, data-* or custom attributes for the element. If the value is a string or a function that returns a string, it serves as a shorthand for a style class definition. Every component documentation has a dedicated segment to document the available section names in the interactive PT Viewer. Panel Example In this example, a Panel is customized with various options through pt . The styling is overriden with Tailwind CSS and header receives custom attributes along with a click event. The attributes passed to the header are not available in the component API, thanks to PassThrough feature, this is no longer an issue as you are not limited to the component api. Note that, you may avoid the ! based overrides in Tailwind classes if you setup CSS Layers with ExhaustiveUI. Visit the Override section at Tailwind integration for examples.
769
+ In traditional 3rd party UI libraries, users are limited to the API provided by component author. This API commonly consists of inputs, outputs, and content projection. Whenever a requirement emerges for a new customization option in
770
+ the API, the component author needs to develop and publish it with a new release.
771
+
772
+ The pass through feature is a key element to implement this vision by exposing the component internals in order to apply arbitrary attributes and listeners to the DOM elements. The primary advantage of this approach is that it frees
773
+ you from being restricted by the main component API. We recommend considering the pass-through feature whenever you need to tailor a component that lacks a built-in feature for your specific requirement.
774
+
775
+ Each component has a special `pt` property to define an object with keys corresponding to the available DOM elements. A value of a key can either be a string, an object or a function to define the arbitrary properties such as
776
+ styling, aria, data-* or custom attributes for the element. If the value is a string or a function that returns a string, it serves as a shorthand for a style class definition. Every component documentation has a dedicated segment to
777
+ document the available section names in the interactive PT Viewer.
778
+
779
+ ### Panel Example
780
+
781
+ In this example, a Panel is customized with various options through `pt`. The styling is overriden with Tailwind CSS and header receives custom attributes along with a click event. The attributes passed to the header are not
782
+ available in the component API, thanks to PassThrough feature, this is no longer an issue as you are not limited to the component api. Note that, you may avoid the `!` based overrides in Tailwind classes if you setup CSS Layers
783
+ with ExhaustiveUI. Visit the [Override](https://exhaustive-ui.com/tailwind) section at Tailwind integration for examples.
555
784
 
556
785
  ## Lifecycle
557
786
 
558
- Lifecycle hooks of components are exposed as pass through using the hooks property so that callback functions can be registered. Available callbacks are onBeforeInit , onInit , onChanges , onDoCheck , onAfterContentInit , onAfterContentChecked , onAfterViewInit , onAfterViewChecked and onDestroy . Refer to the Angular documentation for detailed information about lifecycle hooks.
787
+ Lifecycle hooks of components are exposed as pass through using the `hooks` property so that callback functions can be registered. Available callbacks are `onBeforeInit`, `onInit`, `onChanges`, `onDoCheck`,
788
+ `onAfterContentInit`, `onAfterContentChecked`, `onAfterViewInit`, `onAfterViewChecked` and `onDestroy`. Refer to the Angular documentation for detailed information about lifecycle hooks.
559
789
 
560
790
  ## Pcprefix
561
791
 
562
- A UI component may also use other UI components, in this case section names are prefixed with pc (Prime Component) to denote the ExhaustiveUI component begin used. This distinguishes components from standard DOM elements and indicating the necessity for a nested structure. For example, the badge section is identified as pcBadge because the button component incorporates the badge component internally.
792
+ A UI component may also use other UI components, in this case section names are prefixed with `pc` (Prime Component) to denote the ExhaustiveUI component begin used. This distinguishes components from standard DOM elements and
793
+ indicating the necessity for a nested structure. For example, the `badge` section is identified as `pcBadge` because the button component incorporates the badge component internally.
563
794
 
564
795
  ## Ptoptions
565
796
 
566
- The ⁠ptOptions property determines how a component's local PassThrough configuration merges with the global PT configuration, as demonstrated in the following examples using both global and component-level settings. The mergeSections defines whether the sections from the main configuration gets added and the mergeProps controls whether to override or merge the defined props. Defaults are true for mergeSections and false for mergeProps . Global Configuration mergeSections: true, mergeProps: false (default) mergeSections: true, mergeProps: true mergeSections: false, mergeProps: true mergeSections: false, mergeProps: false
797
+ The `⁠ptOptions` property determines how a component's local PassThrough configuration merges with the global PT configuration, as demonstrated in the following examples using both global and component-level settings.
798
+
799
+ The `mergeSections` defines whether the sections from the main configuration gets added and the `mergeProps` controls whether to override or merge the defined props. Defaults are `true` for `mergeSections` and
800
+ `false` for `mergeProps`.
801
+
802
+ ### Global Configuration
803
+
804
+ ```typescript
805
+ import { ApplicationConfig } from '@angular/core';
806
+ import { provideExhaustive } from '@exhaustive-ui/core/config';
807
+
808
+ export const appConfig: ApplicationConfig = {
809
+ providers: [
810
+ provideExhaustive({
811
+ pt: {
812
+ panel: {
813
+ header: {
814
+ 'data-custom': 'acme-panel',
815
+ class: 'bg-primary text-primary-contrast'
816
+ },
817
+ content: 'font-medium'
818
+ }
819
+ }
820
+ })
821
+ ]
822
+ };
823
+ ```
824
+
825
+ ### mergeSections: true, mergeProps: false (default)
826
+
827
+ ```typescript
828
+ import { Component } from '@angular/core';
829
+ import { Panel, PanelModule, PanelPassThrough } from '@exhaustive-ui/core/panel';
830
+
831
+ @Component({
832
+ selector: 'ptoptions-doc',
833
+ template: \
834
+ ```
835
+
836
+ ### mergeSections: true, mergeProps: true
837
+
838
+ ```typescript
839
+ import { Component } from '@angular/core';
840
+ import { Panel, PanelModule, PanelPassThrough } from '@exhaustive-ui/core/panel';
841
+
842
+ @Component({
843
+ selector: 'ptoptions-doc',
844
+ template: \
845
+ ```
846
+
847
+ ### mergeSections: false, mergeProps: true
848
+
849
+ ```typescript
850
+ import { Component } from '@angular/core';
851
+ import { Panel, PanelModule, PanelPassThrough } from '@exhaustive-ui/core/panel';
852
+
853
+ @Component({
854
+ selector: 'ptoptions-doc',
855
+ template: \
856
+ ```
857
+
858
+ ### mergeSections: false, mergeProps: false
859
+
860
+ ```typescript
861
+ import { Component } from '@angular/core';
862
+ import { Panel, PanelModule, PanelPassThrough } from '@exhaustive-ui/core/panel';
863
+
864
+ @Component({
865
+ selector: 'ptoptions-doc',
866
+ template: \
867
+ ```
567
868
 
568
869
  ---
569
870
 
@@ -571,33 +872,342 @@ The ⁠ptOptions property determines how a component's local PassThrough configu
571
872
 
572
873
  Integration between ExhaustiveUI and Tailwind CSS.
573
874
 
574
- ## Animations
875
+ ## Overview
575
876
 
576
- The plugin also adds extended animation utilities that can be used with the styleclass and animateonscroll directives.
877
+ Tailwind CSS is a popular CSS framework based on a utility-first design. The core provides flexible CSS classes with predefined CSS rules to build your own UI elements. For example, instead of an opinionated `btn` class as in
878
+ Bootstrap, Tailwind offers primitive classes like `bg-blue-500`, `rounded` and `p-4` to apply a button. A set of reusable classes can also be grouped as a Tailwind CSS component and there are even a couple of libraries
879
+ that take this approach to build components specifically for Tailwind.
880
+
881
+ Tailwind is an outstanding CSS library, however it lacks a true comprehensive UI suite when combined with Angular, this is where ExhaustiveUI comes in by providing a wide range of highly accessible and feature rich UI component
882
+ library. The core of ExhaustiveUI does not depend on Tailwind CSS.
883
+
884
+ ## Plugin
885
+
886
+ The [@exhaustive-ui/tailwindcss](https://www.npmjs.com/package/@exhaustive-ui/tailwindcss) is a plugin to provide first class integration between ExhaustiveUI and Tailwind CSS. It
887
+ is designed to work both in styled and unstyled modes. In styled mode, for instance the semantic colors such as primary and surfaces are provided as Tailwind utilities e.g. `bg-primary`, `text-surface-500`,
888
+ `text-muted-color`.
889
+
890
+ If you haven't already done so, start by integrating Tailwind into your project. Detailed steps for this process can be found in the Tailwind
891
+ [documentation](https://tailwindcss.com/). After successfully installing Tailwind, proceed with the installation of the ExhaustiveUiTailwind plugin. This single npm package comes
892
+ with two libraries: the CSS version is compatible with Tailwind v4, the recommended version, while the JS version is designed for Tailwind v3.
893
+
894
+ ### Tailwind v4
895
+
896
+ In the CSS file that contains the tailwindcss import, add the `@exhaustive-ui/tailwindcss` import as well.
897
+
898
+ For a comprehensive starter guide, review the [ExhaustiveUI](https://github.com/e-xiste/exhaustive-ui) repository which demonstrates the integration.
899
+
900
+ ### Tailwind v3
901
+
902
+ Use the plugins option in your Tailwind config file to configure the plugin.
903
+
904
+ ## Extensions
905
+
906
+ The plugin extends the default configuration with a new set of utilities. All variants and breakpoints are supported e.g.
907
+ `dark:sm:hover:bg-primary`.
908
+
909
+ ### Color Palette
910
+
911
+ Class
912
+ Property
913
+ primary-[50-950]
914
+ Primary color palette.
915
+ surface-[0-950]
916
+ Surface color palette.
917
+ primary
918
+ Default primary color.
919
+ primary-contrast
920
+ Default primary contrast color.
921
+ primary-emphasis
922
+ Default primary emphasis color.
923
+ border-surface
924
+ Default primary emphasis color.
925
+ bg-emphasis
926
+ Emphasis background e.g. hovered element.
927
+ bg-highlight
928
+ Highlight background.
929
+ bg-highlight-emphasis
930
+ Highlight background with emphasis.
931
+ rounded-border
932
+ Border radius.
933
+ text-color
934
+ Text color with emphasis.
935
+ text-color-emphasis
936
+ Default primary emphasis color.
937
+ text-muted-color
938
+ Secondary text color.
939
+ text-muted-color-emphasis
940
+ Secondary text color with emphasis.
941
+
942
+ ## Dark Mode
943
+
944
+ In styled mode, ExhaustiveUI uses the `system` as the default `darkModeSelector` in theme configuration. If you have a dark mode switch in your application, ensure that `darkModeSelector` is aligned with the Tailwind
945
+ dark variant for seamless integration. Note that, this particular configuration isn't required if you're utilizing the default system color scheme.
946
+
947
+ Suppose that, the darkModeSelector is set as `my-app-dark` in ExhaustiveUI.
948
+
949
+ ### Tailwind v4
950
+
951
+ Add a custom variant for dark with a custom selector.
952
+
953
+ ### Tailwind v3
954
+
955
+ Use the plugins option in your Tailwind config file to configure the plugin.
956
+
957
+ ## Override
958
+
959
+ Tailwind utilities may not be able to override the default styling of components due to css specificity, there are two possible solutions; Import and CSS Layer.
960
+
961
+ ### Important
962
+
963
+ Use the `!` important modifier to enforce the styling: Tailwind v4 places it at the end of the class name, Tailwind v3 at the start. This is not the recommend approach, and should be used as last resort to avoid adding
964
+ unnecessary style classes to your bundle.
965
+
966
+ Tailwind v4
967
+
968
+ Tailwind v3
969
+
970
+ ### CSS Layer
971
+
972
+ CSS Layer provides control over the css specificity so that Tailwind utilities can safely override components.
973
+
974
+ Tailwind v4
975
+
976
+ Ensure `exhaustive` layer is after `theme` and `base`, but before the other Tailwind layers such as `utilities`.
977
+
978
+ No change in the CSS configuration is required.
979
+
980
+ Tailwind v3
981
+
982
+ The `exhaustive` layer should be between base and utilities.
983
+
984
+ Tailwind v3 does not use native `layer` so needs to be defined with CSS.
985
+
986
+ ## Color Palette
987
+
988
+ ExhaustiveUI color palette as utility classes.
989
+
990
+ ```typescript
991
+ import { Component } from '@angular/core';
992
+
993
+ @Component({
994
+ template: `
995
+ <div class="card">
996
+ <div class="flex flex-col gap-12">
997
+ <ul class="p-0 m-0 list-none flex sm:flex-col gap-4 flex-wrap sm:flex-nowrap">
998
+ <li *ngFor="let color of colors; let i = index" [ngStyle]="{ 'min-width': '6rem' }" class="flex-auto">
999
+ <span class="font-medium capitalize block mb-2 text-center sm:text-left">{{ color }}</span>
1000
+ <div class="flex gap-4 flex-auto flex-col sm:flex-row">
1001
+ <div *ngFor="let shade of shades" [ngClass]="{ invisible: color === 'primary' && shade === 0 }" class="flex flex-col items-center gap-1 flex-1">
1002
+ <div class="rounded-sm h-8 w-full" [ngStyle]="{ 'background-color': 'var(--p-' + color + '-' + shade + ')' }"></div>
1003
+ <span class="text-sm text-surface-500 dark:text-surface-400 font-medium">{{ shade }}</span>
1004
+ </div>
1005
+ </div>
1006
+ </li>
1007
+ </ul>
1008
+ <div class="flex gap-6 flex-wrap">
1009
+ <div class="rounded-border p-4 border border-transparent flex items-center justify-center bg-primary hover:bg-primary-emphasis text-primary-contrast font-medium flex-auto transition-colors">primary</div>
1010
+ <div class="rounded-border p-4 border border-transparent flex items-center justify-center bg-highlight hover:bg-highlight-emphasis font-medium flex-auto transition-colors">highlight</div>
1011
+ <div class="rounded-border p-4 border border-surface flex items-center justify-center text-muted-color hover:text-color hover:bg-emphasis font-medium flex-auto transition-colors">box</div>
1012
+ </div>
1013
+ </div>
1014
+ </div>
1015
+ `,
1016
+ standalone: true,
1017
+ imports: []
1018
+ })
1019
+ export class TailwindColorpaletteDemo {
1020
+ shades: number[] = [0, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
1021
+ colors: string[] = ['primary', 'surface'];
1022
+ }
1023
+ ```
1024
+
1025
+ ## Form
1026
+
1027
+ Using Tailwind utilities for the responsive layout of a form with ExhaustiveUI components.
577
1028
 
578
1029
  ```typescript
579
1030
  import { Component, OnInit } from '@angular/core';
580
1031
  import { FormsModule } from '@angular/forms';
1032
+ import { DatePickerModule } from '@exhaustive-ui/core/datepicker';
581
1033
  import { SelectModule } from '@exhaustive-ui/core/select';
1034
+ import { InputTextModule } from '@exhaustive-ui/core/inputtext';
1035
+ import { Country } from '@/domain/customer';
582
1036
 
583
1037
  @Component({
584
1038
  template: `
585
- <div class="card">
586
- <p-select [(ngModel)]="animation" [options]="animations" placeholder="Select One" class="w-full sm:w-44" />
587
- <div class="py-8 overflow-hidden">
588
- <div [ngClass]="dynamicAnimationClasses"></div>
1039
+ <div class="card flex sm:justify-center">
1040
+ <div class="flex flex-col gap-6 w-full sm:w-auto">
1041
+ <div class="flex flex-col sm:flex-row sm:items-center gap-6">
1042
+ <div class="flex-auto">
1043
+ <label for="firstname" class="block font-semibold mb-2">Firstname</label>
1044
+ <input type="text" pInputText id="firstname" class="w-full" />
1045
+ </div>
1046
+ <div class="flex-auto">
1047
+ <label for="lastname" class="block font-semibold mb-2">Lastname</label>
1048
+ <input type="text" pInputText id="lastname" class="w-full" />
1049
+ </div>
1050
+ </div>
1051
+ <div class="flex flex-col sm:flex-row sm:items-center gap-6">
1052
+ <div class="flex-1">
1053
+ <label for="date" class="block font-semibold mb-2">Date</label>
1054
+ <p-datepicker inputId="date" class="w-full" />
1055
+ </div>
1056
+ <div class="flex-1">
1057
+ <label for="country" class="block font-semibold mb-2">Country</label>
1058
+ <p-select [options]="countries" [(ngModel)]="selectedCountry" optionLabel="name" [showClear]="true" placeholder="Select a Country">
1059
+ <ng-template pTemplate="selectedItem">
1060
+ <div class="flex items-center gap-2" *ngIf="selectedCountry">
1061
+ <img src="https://exhaustive-ui.com/demo/flag/flag_placeholder.png" [class]="'flag flag-' + selectedCountry.code.toLowerCase()" style="width: 18px" />
1062
+ <div>{{ selectedCountry.name }}</div>
1063
+ </div>
1064
+ </ng-template>
1065
+ <ng-template let-country pTemplate="item">
1066
+ <div class="flex items-center gap-2">
1067
+ <img src="https://exhaustive-ui.com/demo/flag/flag_placeholder.png" [class]="'flag flag-' + country.code.toLowerCase()" style="width: 18px" />
1068
+ <div>{{ country.name }}</div>
1069
+ </div>
1070
+ </ng-template>
1071
+ </p-select>
1072
+ </div>
1073
+ </div>
1074
+ <div class="flex-auto">
1075
+ <label for="message" class="block font-semibold mb-2">Message</label>
1076
+ <textarea pTextarea id="message" class="w-full" rows="4"></textarea>
1077
+ </div>
589
1078
  </div>
590
1079
  </div>
591
- <h3>Animations</h3>
592
- <div class="doc-tablewrapper">
593
- <table class="doc-table">
594
- <thead>
595
- <tr>
596
- <th>Class</th>
597
- <th>Property</th>
598
- </tr>
599
- </thead>
600
- <tbody>
1080
+ `,
1081
+ standalone: true,
1082
+ imports: [DatePickerModule, SelectModule, InputTextModule, FormsModule]
1083
+ })
1084
+ export class TailwindFormDemo implements OnInit {
1085
+ countries: any[] | undefined;
1086
+ selectedCountry: string | undefined;
1087
+
1088
+ ngOnInit() {
1089
+ this.countries = [
1090
+ { name: 'Australia', code: 'AU' },
1091
+ { name: 'Brazil', code: 'BR' },
1092
+ { name: 'China', code: 'CN' },
1093
+ { name: 'Egypt', code: 'EG' },
1094
+ { name: 'France', code: 'FR' },
1095
+ { name: 'Germany', code: 'DE' },
1096
+ { name: 'India', code: 'IN' },
1097
+ { name: 'Japan', code: 'JP' },
1098
+ { name: 'Spain', code: 'ES' },
1099
+ { name: 'United States', code: 'US' }
1100
+ ];
1101
+ }
1102
+ }
1103
+ ```
1104
+
1105
+ ## Headless
1106
+
1107
+ A headless ExhaustiveUI dialog with a custom UI.
1108
+
1109
+ ```typescript
1110
+ import { Component } from '@angular/core';
1111
+ import { ButtonModule } from '@exhaustive-ui/core/button';
1112
+ import { DialogModule } from '@exhaustive-ui/core/dialog';
1113
+ import { InputTextModule } from '@exhaustive-ui/core/inputtext';
1114
+
1115
+ @Component({
1116
+ template: `
1117
+ <div class="card flex justify-center">
1118
+ <p-button (click)="showDialog()" icon="pi pi-user" label="Login" />
1119
+ <p-dialog maskStyleClass="backdrop-blur-xs" [(visible)]="visible" styleClass="border-0! bg-transparent!">
1120
+ <ng-template pTemplate="headless">
1121
+ <div class="flex flex-col px-8 py-8 gap-6 rounded-2xl" style="border-radius: 12px; background-image: radial-gradient(circle at left top, var(--p-primary-400), var(--p-primary-700))">
1122
+ <svg width="31" height="33" viewBox="0 0 31 33" fill="none" xmlns="http://www.w3.org/2000/svg" class="block mx-auto">
1123
+ <path d="M15.1934 0V0V0L0.0391235 5.38288L2.35052 25.3417L15.1934 32.427V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1934 0Z" fill="var(--p-primary-color)" />
1124
+ <mask id="mask0_1_52" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="0" y="0" width="31" height="33">
1125
+ <path d="M15.1934 0V0V0L0.0391235 5.38288L2.35052 25.3417L15.1934 32.427V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1934 0Z" fill="var(--ground-background)" />
1126
+ </mask>
1127
+ <g mask="url(#mask0_1_52)">
1128
+ <path fill-rule="evenodd" clip-rule="evenodd" d="M15.1935 0V3.5994V3.58318V20.0075V20.0075V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1935 0Z" fill="var(--p-primary-color)" />
1129
+ </g>
1130
+ <path d="M19.6399 15.3776L18.1861 15.0547L19.3169 16.6695V21.6755L23.1938 18.4458V12.9554L21.4169 13.6013L19.6399 15.3776Z" fill="var(--ground-background)" />
1131
+ <path d="M10.5936 15.3776L12.0474 15.0547L10.9166 16.6695V21.6755L7.03966 18.4458V12.9554L8.81661 13.6013L10.5936 15.3776Z" fill="var(--ground-background)" />
1132
+ <path
1133
+ fill-rule="evenodd"
1134
+ clip-rule="evenodd"
1135
+ d="M11.3853 16.9726L12.6739 15.0309L13.4793 15.5163H16.7008L17.5061 15.0309L18.7947 16.9726V24.254L17.8283 25.7103L16.7008 26.843H13.4793L12.3518 25.7103L11.3853 24.254V16.9726Z"
1136
+ fill="var(--ground-background)"
1137
+ />
1138
+ <path d="M19.3168 24.7437L21.4168 22.6444V20.5451L19.3168 22.3214V24.7437Z" fill="var(--ground-background)" />
1139
+ <path d="M10.9166 24.7437L8.81662 22.6444V20.5451L10.9166 22.3214V24.7437Z" fill="var(--ground-background)" />
1140
+ <path
1141
+ fill-rule="evenodd"
1142
+ clip-rule="evenodd"
1143
+ d="M13.0167 5.68861L11.7244 8.7568L13.8244 14.8932H14.7936V5.68861H13.0167ZM15.4397 5.68861V14.8932H16.5706L18.5091 8.7568L17.2167 5.68861H15.4397Z"
1144
+ fill="var(--ground-background)"
1145
+ />
1146
+ <path d="M13.8244 14.8932L6.87813 12.3094L5.90888 8.27235L11.8859 8.7568L13.9859 14.8932H13.8244Z" fill="var(--ground-background)" />
1147
+ <path d="M16.5706 14.8932L23.5169 12.3094L24.4861 8.27235L18.3476 8.7568L16.4091 14.8932H16.5706Z" fill="var(--ground-background)" />
1148
+ <path d="M18.8321 8.27235L22.2245 7.94938L19.9629 5.68861H17.7013L18.8321 8.27235Z" fill="var(--ground-background)" />
1149
+ <path d="M11.4013 8.27235L8.00893 7.94938L10.2705 5.68861H12.5321L11.4013 8.27235Z" fill="var(--ground-background)" />
1150
+ </svg>
1151
+ <div class="inline-flex flex-col gap-2">
1152
+ <label for="username" class="text-primary-50 font-semibold">Username</label>
1153
+ <input pInputText id="username" class="bg-white/20! border-0! p-4! text-primary-50! w-80" />
1154
+ </div>
1155
+ <div class="inline-flex flex-col gap-2">
1156
+ <label for="password" class="text-primary-50 font-semibold">Password</label>
1157
+ <input pInputText id="password" class="bg-white/20! border-0! p-4! text-primary-50! w-80" type="password" />
1158
+ </div>
1159
+ <div class="flex items-center gap-4">
1160
+ <p-button label="Cancel" (click)="closeDialog()" [text]="true" styleClass="p-4! w-full text-primary-50! border! border-white/30! hover:bg-white/10!" class="w-full" />
1161
+ <p-button label="Sign-In" (click)="closeDialog()" [text]="true" styleClass="p-4! w-full text-primary-50! border! border-white/30! hover:bg-white/10!" class="w-full" />
1162
+ </div>
1163
+ </div>
1164
+ </ng-template>
1165
+ </p-dialog>
1166
+ </div>
1167
+ `,
1168
+ standalone: true,
1169
+ imports: [ButtonModule, DialogModule, InputTextModule]
1170
+ })
1171
+ export class TailwindHeadlessDemo {
1172
+ visible: boolean = false;
1173
+
1174
+ showDialog() {
1175
+ this.visible = true;
1176
+ }
1177
+
1178
+ closeDialog() {
1179
+ this.visible = false;
1180
+ }
1181
+ }
1182
+ ```
1183
+
1184
+ ## Animations
1185
+
1186
+ The plugin also adds extended animation utilities that can be used with the styleclass and animateonscroll directives.
1187
+
1188
+ ```typescript
1189
+ import { Component, OnInit } from '@angular/core';
1190
+ import { FormsModule } from '@angular/forms';
1191
+ import { SelectModule } from '@exhaustive-ui/core/select';
1192
+
1193
+ @Component({
1194
+ template: `
1195
+ <div class="card">
1196
+ <p-select [(ngModel)]="animation" [options]="animations" placeholder="Select One" class="w-full sm:w-44" />
1197
+ <div class="py-8 overflow-hidden">
1198
+ <div [ngClass]="dynamicAnimationClasses"></div>
1199
+ </div>
1200
+ </div>
1201
+ <h3>Animations</h3>
1202
+ <div class="doc-tablewrapper">
1203
+ <table class="doc-table">
1204
+ <thead>
1205
+ <tr>
1206
+ <th>Class</th>
1207
+ <th>Property</th>
1208
+ </tr>
1209
+ </thead>
1210
+ <tbody>
601
1211
  <tr>
602
1212
  <td>animate-fadein</td>
603
1213
  <td>fadein 0.15s linear</td>
@@ -990,245 +1600,98 @@ export class TailwindAnimationsDemo implements OnInit {
990
1600
  }
991
1601
  ```
992
1602
 
993
- ## Colorpalette
1603
+ ---
994
1604
 
995
- ExhaustiveUI color palette as utility classes.
1605
+ # LLMs.txt
996
1606
 
997
- ```typescript
998
- import { Component } from '@angular/core';
1607
+ LLM-optimized documentation endpoints for ExhaustiveUI components.
999
1608
 
1000
- @Component({
1001
- template: `
1002
- <div class="card">
1003
- <div class="flex flex-col gap-12">
1004
- <ul class="p-0 m-0 list-none flex sm:flex-col gap-4 flex-wrap sm:flex-nowrap">
1005
- <li *ngFor="let color of colors; let i = index" [ngStyle]="{ 'min-width': '6rem' }" class="flex-auto">
1006
- <span class="font-medium capitalize block mb-2 text-center sm:text-left">{{ color }}</span>
1007
- <div class="flex gap-4 flex-auto flex-col sm:flex-row">
1008
- <div *ngFor="let shade of shades" [ngClass]="{ invisible: color === 'primary' && shade === 0 }" class="flex flex-col items-center gap-1 flex-1">
1009
- <div class="rounded-sm h-8 w-full" [ngStyle]="{ 'background-color': 'var(--p-' + color + '-' + shade + ')' }"></div>
1010
- <span class="text-sm text-surface-500 dark:text-surface-400 font-medium">{{ shade }}</span>
1011
- </div>
1012
- </div>
1013
- </li>
1014
- </ul>
1015
- <div class="flex gap-6 flex-wrap">
1016
- <div class="rounded-border p-4 border border-transparent flex items-center justify-center bg-primary hover:bg-primary-emphasis text-primary-contrast font-medium flex-auto transition-colors">primary</div>
1017
- <div class="rounded-border p-4 border border-transparent flex items-center justify-center bg-highlight hover:bg-highlight-emphasis font-medium flex-auto transition-colors">highlight</div>
1018
- <div class="rounded-border p-4 border border-surface flex items-center justify-center text-muted-color hover:text-color hover:bg-emphasis font-medium flex-auto transition-colors">box</div>
1019
- </div>
1020
- </div>
1021
- </div>
1022
- `,
1023
- standalone: true,
1024
- imports: []
1025
- })
1026
- export class TailwindColorpaletteDemo {
1027
- shades: number[] = [0, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
1028
- colors: string[] = ['primary', 'surface'];
1029
- }
1030
- ```
1609
+ ## /llms.txt
1031
1610
 
1032
- ## Darkmode
1611
+ The [llms.txt](https://llmstxt.org/) file is an industry standard that helps AI models better understand and navigate the ExhaustiveUI documentation. It lists key pages in a
1612
+ structured format, making it easier for LLMs to retrieve relevant information.
1033
1613
 
1034
- In styled mode, ExhaustiveUI uses the system as the default darkModeSelector in theme configuration. If you have a dark mode switch in your application, ensure that darkModeSelector is aligned with the Tailwind dark variant for seamless integration. Note that, this particular configuration isn't required if you're utilizing the default system color scheme. Suppose that, the darkModeSelector is set as my-app-dark in ExhaustiveUI. Tailwind v4 Add a custom variant for dark with a custom selector. Tailwind v3 Use the plugins option in your Tailwind config file to configure the plugin.
1614
+ [
1035
1615
 
1036
- ## Extensions
1616
+ ](/llms/llms.txt)
1037
1617
 
1038
- The plugin extends the default configuration with a new set of utilities. All variants and breakpoints are supported e.g. dark:sm:hover:bg-primary . Color Palette Class Property primary-[50-950] Primary color palette. surface-[0-950] Surface color palette. primary Default primary color. primary-contrast Default primary contrast color. primary-emphasis Default primary emphasis color. border-surface Default primary emphasis color. bg-emphasis Emphasis background e.g. hovered element. bg-highlight Highlight background. bg-highlight-emphasis Highlight background with emphasis. rounded-border Border radius. text-color Text color with emphasis. text-color-emphasis Default primary emphasis color. text-muted-color Secondary text color. text-muted-color-emphasis Secondary text color with emphasis.
1618
+ ## /llms-full.txt
1039
1619
 
1040
- ## Form
1620
+ The `llms-full.txt` file is a complete list of all the pages in the ExhaustiveUI documentation. It is used to help AI models understand the entire documentation set.
1041
1621
 
1042
- Using Tailwind utilities for the responsive layout of a form with ExhaustiveUI components.
1622
+ [
1043
1623
 
1044
- ```typescript
1045
- import { Component, OnInit } from '@angular/core';
1046
- import { FormsModule } from '@angular/forms';
1047
- import { DatePickerModule } from '@exhaustive-ui/core/datepicker';
1048
- import { SelectModule } from '@exhaustive-ui/core/select';
1049
- import { InputTextModule } from '@exhaustive-ui/core/inputtext';
1050
- import { Country } from '@/domain/customer';
1624
+ ](/llms/llms-full.txt)
1051
1625
 
1052
- @Component({
1053
- template: `
1054
- <div class="card flex sm:justify-center">
1055
- <div class="flex flex-col gap-6 w-full sm:w-auto">
1056
- <div class="flex flex-col sm:flex-row sm:items-center gap-6">
1057
- <div class="flex-auto">
1058
- <label for="firstname" class="block font-semibold mb-2">Firstname</label>
1059
- <input type="text" pInputText id="firstname" class="w-full" />
1060
- </div>
1061
- <div class="flex-auto">
1062
- <label for="lastname" class="block font-semibold mb-2">Lastname</label>
1063
- <input type="text" pInputText id="lastname" class="w-full" />
1064
- </div>
1065
- </div>
1066
- <div class="flex flex-col sm:flex-row sm:items-center gap-6">
1067
- <div class="flex-1">
1068
- <label for="date" class="block font-semibold mb-2">Date</label>
1069
- <p-datepicker inputId="date" class="w-full" />
1070
- </div>
1071
- <div class="flex-1">
1072
- <label for="country" class="block font-semibold mb-2">Country</label>
1073
- <p-select [options]="countries" [(ngModel)]="selectedCountry" optionLabel="name" [showClear]="true" placeholder="Select a Country">
1074
- <ng-template pTemplate="selectedItem">
1075
- <div class="flex items-center gap-2" *ngIf="selectedCountry">
1076
- <img src="https://exhaustive-ui.com/demo/flag/flag_placeholder.png" [class]="'flag flag-' + selectedCountry.code.toLowerCase()" style="width: 18px" />
1077
- <div>{{ selectedCountry.name }}</div>
1078
- </div>
1079
- </ng-template>
1080
- <ng-template let-country pTemplate="item">
1081
- <div class="flex items-center gap-2">
1082
- <img src="https://exhaustive-ui.com/demo/flag/flag_placeholder.png" [class]="'flag flag-' + country.code.toLowerCase()" style="width: 18px" />
1083
- <div>{{ country.name }}</div>
1084
- </div>
1085
- </ng-template>
1086
- </p-select>
1087
- </div>
1088
- </div>
1089
- <div class="flex-auto">
1090
- <label for="message" class="block font-semibold mb-2">Message</label>
1091
- <textarea pTextarea id="message" class="w-full" rows="4"></textarea>
1092
- </div>
1093
- </div>
1094
- </div>
1095
- `,
1096
- standalone: true,
1097
- imports: [DatePickerModule, SelectModule, InputTextModule, FormsModule]
1098
- })
1099
- export class TailwindFormDemo implements OnInit {
1100
- countries: any[] | undefined;
1101
- selectedCountry: string | undefined;
1626
+ ## .md extension
1102
1627
 
1103
- ngOnInit() {
1104
- this.countries = [
1105
- { name: 'Australia', code: 'AU' },
1106
- { name: 'Brazil', code: 'BR' },
1107
- { name: 'China', code: 'CN' },
1108
- { name: 'Egypt', code: 'EG' },
1109
- { name: 'France', code: 'FR' },
1110
- { name: 'Germany', code: 'DE' },
1111
- { name: 'India', code: 'IN' },
1112
- { name: 'Japan', code: 'JP' },
1113
- { name: 'Spain', code: 'ES' },
1114
- { name: 'United States', code: 'US' }
1115
- ];
1116
- }
1117
- }
1118
- ```
1628
+ Add a `.md` to a page's URL to display a Markdown version of that page.
1119
1629
 
1120
- ## Headless
1630
+ [
1121
1631
 
1122
- A headless ExhaustiveUI dialog with a custom UI.
1632
+ ](/llms/components/button.md)
1123
1633
 
1124
- ```typescript
1125
- import { Component } from '@angular/core';
1126
- import { ButtonModule } from '@exhaustive-ui/core/button';
1127
- import { DialogModule } from '@exhaustive-ui/core/dialog';
1128
- import { InputTextModule } from '@exhaustive-ui/core/inputtext';
1634
+ ## Agent Skill
1129
1635
 
1130
- @Component({
1131
- template: `
1132
- <div class="card flex justify-center">
1133
- <p-button (click)="showDialog()" icon="pi pi-user" label="Login" />
1134
- <p-dialog maskStyleClass="backdrop-blur-xs" [(visible)]="visible" styleClass="border-0! bg-transparent!">
1135
- <ng-template pTemplate="headless">
1136
- <div class="flex flex-col px-8 py-8 gap-6 rounded-2xl" style="border-radius: 12px; background-image: radial-gradient(circle at left top, var(--p-primary-400), var(--p-primary-700))">
1137
- <svg width="31" height="33" viewBox="0 0 31 33" fill="none" xmlns="http://www.w3.org/2000/svg" class="block mx-auto">
1138
- <path d="M15.1934 0V0V0L0.0391235 5.38288L2.35052 25.3417L15.1934 32.427V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1934 0Z" fill="var(--p-primary-color)" />
1139
- <mask id="mask0_1_52" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="0" y="0" width="31" height="33">
1140
- <path d="M15.1934 0V0V0L0.0391235 5.38288L2.35052 25.3417L15.1934 32.427V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1934 0Z" fill="var(--ground-background)" />
1141
- </mask>
1142
- <g mask="url(#mask0_1_52)">
1143
- <path fill-rule="evenodd" clip-rule="evenodd" d="M15.1935 0V3.5994V3.58318V20.0075V20.0075V32.427V32.427L28.0364 25.3417L30.3478 5.38288L15.1935 0Z" fill="var(--p-primary-color)" />
1144
- </g>
1145
- <path d="M19.6399 15.3776L18.1861 15.0547L19.3169 16.6695V21.6755L23.1938 18.4458V12.9554L21.4169 13.6013L19.6399 15.3776Z" fill="var(--ground-background)" />
1146
- <path d="M10.5936 15.3776L12.0474 15.0547L10.9166 16.6695V21.6755L7.03966 18.4458V12.9554L8.81661 13.6013L10.5936 15.3776Z" fill="var(--ground-background)" />
1147
- <path
1148
- fill-rule="evenodd"
1149
- clip-rule="evenodd"
1150
- d="M11.3853 16.9726L12.6739 15.0309L13.4793 15.5163H16.7008L17.5061 15.0309L18.7947 16.9726V24.254L17.8283 25.7103L16.7008 26.843H13.4793L12.3518 25.7103L11.3853 24.254V16.9726Z"
1151
- fill="var(--ground-background)"
1152
- />
1153
- <path d="M19.3168 24.7437L21.4168 22.6444V20.5451L19.3168 22.3214V24.7437Z" fill="var(--ground-background)" />
1154
- <path d="M10.9166 24.7437L8.81662 22.6444V20.5451L10.9166 22.3214V24.7437Z" fill="var(--ground-background)" />
1155
- <path
1156
- fill-rule="evenodd"
1157
- clip-rule="evenodd"
1158
- d="M13.0167 5.68861L11.7244 8.7568L13.8244 14.8932H14.7936V5.68861H13.0167ZM15.4397 5.68861V14.8932H16.5706L18.5091 8.7568L17.2167 5.68861H15.4397Z"
1159
- fill="var(--ground-background)"
1160
- />
1161
- <path d="M13.8244 14.8932L6.87813 12.3094L5.90888 8.27235L11.8859 8.7568L13.9859 14.8932H13.8244Z" fill="var(--ground-background)" />
1162
- <path d="M16.5706 14.8932L23.5169 12.3094L24.4861 8.27235L18.3476 8.7568L16.4091 14.8932H16.5706Z" fill="var(--ground-background)" />
1163
- <path d="M18.8321 8.27235L22.2245 7.94938L19.9629 5.68861H17.7013L18.8321 8.27235Z" fill="var(--ground-background)" />
1164
- <path d="M11.4013 8.27235L8.00893 7.94938L10.2705 5.68861H12.5321L11.4013 8.27235Z" fill="var(--ground-background)" />
1165
- </svg>
1166
- <div class="inline-flex flex-col gap-2">
1167
- <label for="username" class="text-primary-50 font-semibold">Username</label>
1168
- <input pInputText id="username" class="bg-white/20! border-0! p-4! text-primary-50! w-80" />
1169
- </div>
1170
- <div class="inline-flex flex-col gap-2">
1171
- <label for="password" class="text-primary-50 font-semibold">Password</label>
1172
- <input pInputText id="password" class="bg-white/20! border-0! p-4! text-primary-50! w-80" type="password" />
1173
- </div>
1174
- <div class="flex items-center gap-4">
1175
- <p-button label="Cancel" (click)="closeDialog()" [text]="true" styleClass="p-4! w-full text-primary-50! border! border-white/30! hover:bg-white/10!" class="w-full" />
1176
- <p-button label="Sign-In" (click)="closeDialog()" [text]="true" styleClass="p-4! w-full text-primary-50! border! border-white/30! hover:bg-white/10!" class="w-full" />
1177
- </div>
1178
- </div>
1179
- </ng-template>
1180
- </p-dialog>
1181
- </div>
1182
- `,
1183
- standalone: true,
1184
- imports: [ButtonModule, DialogModule, InputTextModule]
1185
- })
1186
- export class TailwindHeadlessDemo {
1187
- visible: boolean = false;
1188
-
1189
- showDialog() {
1190
- this.visible = true;
1191
- }
1636
+ The markdown files above are also bundled as an [Agent Skill](https://agentskills.io), the `SKILL.md` format supported by coding agents such as Claude Code,
1637
+ Codex, Cursor and OpenCode. Once installed, the agent reads the component docs, API tables and guides from disk whenever it works on ExhaustiveUI code, instead of fetching them from this site each time.
1192
1638
 
1193
- closeDialog() {
1194
- this.visible = false;
1195
- }
1196
- }
1197
- ```
1639
+ Install it with the [skills CLI](https://skills.sh/docs/cli), which asks which agents to set it up for.
1198
1640
 
1199
- ## Override
1200
-
1201
- Tailwind utilities may not be able to override the default styling of components due to css specificity, there are two possible solutions; Import and CSS Layer. Important Use the ! important modifier to enforce the styling: Tailwind v4 places it at the end of the class name, Tailwind v3 at the start. This is not the recommend approach, and should be used as last resort to avoid adding unnecessary style classes to your bundle. Tailwind v4 Tailwind v3 CSS Layer CSS Layer provides control over the css specificity so that Tailwind utilities can safely override components. Tailwind v4 Ensure exhaustive layer is after theme and base , but before the other Tailwind layers such as utilities . No change in the CSS configuration is required. Tailwind v3 The exhaustive layer should be between base and utilities. Tailwind v3 does not use native layer so needs to be defined with CSS.
1202
-
1203
- ## Overview
1641
+ ```bash
1642
+ npx skills add https://exhaustive-ui.com
1204
1643
 
1205
- Tailwind CSS is a popular CSS framework based on a utility-first design. The core provides flexible CSS classes with predefined CSS rules to build your own UI elements. For example, instead of an opinionated btn class as in Bootstrap, Tailwind offers primitive classes like bg-blue-500 , rounded and p-4 to apply a button. A set of reusable classes can also be grouped as a Tailwind CSS component and there are even a couple of libraries that take this approach to build components specifically for Tailwind. Tailwind is an outstanding CSS library, however it lacks a true comprehensive UI suite when combined with Angular, this is where ExhaustiveUI comes in by providing a wide range of highly accessible and feature rich UI component library. The core of ExhaustiveUI does not depend on Tailwind CSS.
1644
+ # update to the latest docs
1645
+ npx skills update exhaustive-ui
1646
+ ```
1206
1647
 
1207
- ## Plugin
1648
+ By default the skill is installed into the current project, so your team gets it too. Add `-g` to install it for your user instead. You can also download the zip and extract it into a folder named `exhaustive-ui` in your
1649
+ agent's skills directory.
1208
1650
 
1209
- The @exhaustive-ui/tailwindcss is a plugin to provide first class integration between ExhaustiveUI and Tailwind CSS. It is designed to work both in styled and unstyled modes. In styled mode, for instance the semantic colors such as primary and surfaces are provided as Tailwind utilities e.g. bg-primary , text-surface-500 , text-muted-color . If you haven't already done so, start by integrating Tailwind into your project. Detailed steps for this process can be found in the Tailwind documentation . After successfully installing Tailwind, proceed with the installation of the ExhaustiveUiTailwind plugin. This single npm package comes with two libraries: the CSS version is compatible with Tailwind v4, the recommended version, while the JS version is designed for Tailwind v3. Tailwind v4 In the CSS file that contains the tailwindcss import, add the @exhaustive-ui/tailwindcss import as well. For a comprehensive starter guide, review the ExhaustiveUI repository which demonstrates the integration. Tailwind v3 Use the plugins option in your Tailwind config file to configure the plugin.
1651
+ [
1210
1652
 
1211
- ---
1653
+ ](/llms/exhaustive-ui-skill.zip)
1212
1654
 
1213
- # LLMs.txt
1655
+ ## MCP Server
1214
1656
 
1215
- LLM-optimized documentation endpoints for ExhaustiveUI components.
1657
+ [@exhaustive-ui/mcp](https://www.npmjs.com/package/@exhaustive-ui/mcp) is a
1658
+ [Model Context Protocol](https://modelcontextprotocol.io) server that gives coding agents such as Claude Code, Cursor, Claude Desktop, VS Code Copilot and Codex
1659
+ tools to query this documentation instead of guessing from PrimeNG memory: list and search components, read a component's docs and API, fetch a complete code example, read the setup guides, and validate an Angular template against the
1660
+ compiled API (unknown inputs or outputs, invalid literal values, unsupported two-way bindings, deprecated inputs, PrimeNG imports and selectors).
1216
1661
 
1217
- ## Agentskill
1662
+ The server reads the files described on this page from the live site, so it always reflects the deployed documentation without reinstalling the package, and keeps them in memory for 15 minutes. A snapshot of the same files is bundled
1663
+ in the package and used when the network is unavailable.
1218
1664
 
1219
- The markdown files above are also bundled as an Agent Skill , the SKILL.md format supported by coding agents such as Claude Code, Codex, Cursor and OpenCode. Once installed, the agent reads the component docs, API tables and guides from disk whenever it works on ExhaustiveUI code, instead of fetching them from this site each time. Install it with the skills CLI , which asks which agents to set it up for. By default the skill is installed into the current project, so your team gets it too. Add -g to install it for your user instead. You can also download the zip and extract it into a folder named exhaustive-ui in your agent's skills directory.
1665
+ Register it with Claude Code:
1220
1666
 
1221
- ## Llmsfulltxt
1667
+ ```bash
1668
+ claude mcp add exhaustive-ui -s user -- npx -y @exhaustive-ui/mcp
1669
+ ```
1222
1670
 
1223
- The llms-full.txt file is a complete list of all the pages in the ExhaustiveUI documentation. It is used to help AI models understand the entire documentation set.
1671
+ Or add it to the MCP configuration of your client (`.cursor/mcp.json`, `claude_desktop_config.json`, `.vscode/mcp.json` with a `servers` key, ...):
1224
1672
 
1225
- ## Llmstxt
1673
+ ```typescript
1674
+ {
1675
+ "mcpServers": {
1676
+ "exhaustive-ui": {
1677
+ "command": "npx",
1678
+ "args": ["-y", "@exhaustive-ui/mcp"]
1679
+ }
1680
+ }
1681
+ }
1682
+ ```
1226
1683
 
1227
- The llms.txt file is an industry standard that helps AI models better understand and navigate the ExhaustiveUI documentation. It lists key pages in a structured format, making it easier for LLMs to retrieve relevant information.
1684
+ The server exposes the `list`, `search`, `get_component`, `get_guide`, `get_example`, `get_setup`, `validate_usage` and `version` tools, the Markdown files of this page as MCP resources, and
1685
+ prompts for the usual tasks (use a component, build a form, theme a component, migrate from PrimeNG, audit usage). Set `EXHAUSTIVE_UI_DOCS_URL` to read another deployment of the docs, for instance a local `ng serve`, and
1686
+ `EXHAUSTIVE_UI_MCP_OFFLINE=1` to only use the bundled snapshot. The package README lists every option.
1228
1687
 
1229
1688
  ## Manifest
1230
1689
 
1231
- /llms/manifest.json describes every component, directive, NgModule, service and exported type as structured data, for tools that need exact facts rather than prose: MCP servers, code generators, linters and design tool integrations. It is generated from the Angular metadata in the compiled library, so selectors and inputs match what the compiler accepts. Each entry point lists its import path, NgModule, services and exported types. Each component or directive lists its selector, inputs with type, allowed values, default, transform and two-way binding, outputs with payload type, templates with their context type, methods, forms support and pass-through keys.
1690
+ [/llms/manifest.json](/llms/manifest.json) describes every component, directive, NgModule, service and exported type as structured data, for tools that need exact facts rather than prose:
1691
+ MCP servers, code generators, linters and design tool integrations. It is generated from the Angular metadata in the compiled library, so selectors and inputs match what the compiler accepts.
1692
+
1693
+ Each entry point lists its import path, NgModule, services and exported types. Each component or directive lists its selector, inputs with type, allowed values, default, transform and two-way binding, outputs with payload type,
1694
+ templates with their context type, methods, forms support and pass-through keys.
1232
1695
 
1233
1696
  ```typescript
1234
1697
  {
@@ -1256,14 +1719,6 @@ The llms.txt file is an industry standard that helps AI models better understand
1256
1719
  }
1257
1720
  ```
1258
1721
 
1259
- ## Markdownextension
1260
-
1261
- Add a .md to a page's URL to display a Markdown version of that page.
1262
-
1263
- ## Mcp
1264
-
1265
- @exhaustive-ui/mcp is a Model Context Protocol server that gives coding agents such as Claude Code, Cursor, Claude Desktop, VS Code Copilot and Codex tools to query this documentation instead of guessing from PrimeNG memory: list and search components, read a component's docs and API, fetch a complete code example, read the setup guides, and validate an Angular template against the compiled API (unknown inputs or outputs, invalid literal values, unsupported two-way bindings, deprecated inputs, PrimeNG imports and selectors). The server reads the files described on this page from the live site, so it always reflects the deployed documentation without reinstalling the package, and keeps them in memory for 15 minutes. A snapshot of the same files is bundled in the package and used when the network is unavailable. Register it with Claude Code: Or add it to the MCP configuration of your client ( .cursor/mcp.json , claude_desktop_config.json , .vscode/mcp.json with a servers key, ...): The server exposes the list , search , get_component , get_guide , get_example , get_setup , validate_usage and version tools, the Markdown files of this page as MCP resources, and prompts for the usual tasks (use a component, build a form, theme a component, migrate from PrimeNG, audit usage). Set EXHAUSTIVE_UI_DOCS_URL to read another deployment of the docs, for instance a local ng serve , and EXHAUSTIVE_UI_MCP_OFFLINE=1 to only use the bundled snapshot. The package README lists every option.
1266
-
1267
1722
  ---
1268
1723
 
1269
1724
  # Accessibility
@@ -1272,27 +1727,185 @@ ExhaustiveUI has WCAG 2.1 AA level compliance.
1272
1727
 
1273
1728
  ## Colors
1274
1729
 
1275
- Colors on a web page should aim a contrast ratio of at least 4.5:1 and consider a selection of colors that do not cause vibration. Good Contrast Color contrast between the background and the foreground content should be sufficient enough to ensure readability. Example below displays two cases with good and bad samples. GOOD BAD Vibration Color vibration is leads to an illusion of motion due to choosing colors that have low visibility against each other. Color combinations need to be picked with caution to avoid vibration. VIBRATE Dark Mode Highly saturated colors should be avoided when used within a dark design scheme as they cause eye strain. Instead desaturated colors should be preferred. Indigo 500 Indigo 200
1730
+ Colors on a web page should aim a contrast ratio of at least **4.5:1** and consider a selection of colors that do not cause vibration.
1731
+
1732
+ ### Good Contrast
1733
+
1734
+ Color contrast between the background and the foreground content should be sufficient enough to ensure readability. Example below displays two cases with good and bad samples.
1735
+
1736
+ GOOD
1737
+ BAD
1738
+
1739
+ ### Vibration
1740
+
1741
+ Color vibration is leads to an illusion of motion due to choosing colors that have low visibility against each other. Color combinations need to be picked with caution to avoid vibration.
1742
+
1743
+ VIBRATE
1744
+
1745
+ ### Dark Mode
1746
+
1747
+ Highly saturated colors should be avoided when used within a dark design scheme as they cause eye strain. Instead desaturated colors should be preferred.
1748
+
1749
+ Indigo 500
1750
+ Indigo 200
1276
1751
 
1277
1752
  ## Formcontrols
1278
1753
 
1279
- Native form elements should be preferred instead of elements that are meant for other purposes like presentation. As an example, button below is rendered as a form control by the browser, can receive focus via tabbing and can be used with space key as well to trigger. On the other hand, a fancy css based button using a div has no keyboard or screen reader support. tabindex is required to make a div element accessible in addition to use a keydown to bring the keyboard support back. To avoid the overload and implementing functionality that is already provided by the browser, native form controls should be preferred. Relations Form components must be related to another element that describes what the form element is used for. This is usually achieved with the label element.
1754
+ Native form elements should be preferred instead of elements that are meant for other purposes like presentation. As an example, button below is rendered as a form control by the browser, can receive focus via tabbing and can be used
1755
+ with space key as well to trigger.
1756
+
1757
+ ```html
1758
+ <button (click)="onButtonClick($event)">Click></button>
1759
+ ```
1760
+
1761
+ On the other hand, a fancy css based button using a div has no keyboard or screen reader support.
1762
+
1763
+ ```html
1764
+ <div class="fancy-button" (click)="onButtonClick($event)">Click</div>
1765
+ ```
1766
+
1767
+ `tabindex` is required to make a div element accessible in addition to use a keydown to bring the keyboard support back. To avoid the overload and implementing functionality that is already provided by the browser, native form
1768
+ controls should be preferred.
1769
+
1770
+ ```html
1771
+ <div class="fancy-button" (click)="onButtonClick($event)" (keydown)="onKeyDown($event)" tabIndex="0">Click</div>
1772
+ ```
1773
+
1774
+ ### Relations
1775
+
1776
+ Form components must be related to another element that describes what the form element is used for. This is usually achieved with the `label` element.
1777
+
1778
+ ```html
1779
+ <label for="myinput">Username:</label>
1780
+ <input id="myinput" type="text" name="username" />
1781
+ ```
1280
1782
 
1281
1783
  ## Introduction
1282
1784
 
1283
- According to the World Health Organization, 15% of the world population has a disability to some degree. As a result, accessibility features in any context such as a ramp for wheelchair users or a multimedia with captions are crucial to ensure content can be consumed by anyone. Disabilities Types of disabilities are diverse so you need to know your audience well and how they interact with the content created. There four main categories; Visual Impairments Blindness, low-level vision or color blindness are the common types of visual impairments. Screen magnifiers and the color blind mode are usually built-in features of the browsers whereas for people who rely on screen readers, page developers are required to make sure content is readable by the readers. Popular readers are NVDA , JAWS and ChromeVox . Hearing Impairments Deafness or hearing loss refers to the inability to hear sounds totally or partially. People with hearing impairments use assistive devices however it may not be enough when interacting with a web page. Common implementation is providing textual alternatives, transcripts and captions for content with audio. Mobility Impairments People with mobility impairments have disabilities related to movement due to loss of a limb, paralysis or other varying reasons. Assistive technologies like a head pointer is a device to interact with a screen whereas keyboard or a trackpad remain as solutions for people who are not able to utilize a mouse. Cognitive Impairments Cognitive impairments have a wider range that includes people with learning disabilities, depression and dyslexia. A well designed content also leads to better user experience for people without disabilities so designing for cognitive impairments result in better design for any user.
1785
+ According to the World Health Organization, 15% of the world population has a disability to some degree. As a result, accessibility features in any context such as a ramp for wheelchair users or a multimedia with captions are crucial
1786
+ to ensure content can be consumed by anyone.
1787
+
1788
+ ### Disabilities
1789
+
1790
+ Types of disabilities are diverse so you need to know your audience well and how they interact with the content created. There four main categories;
1791
+
1792
+ ### Visual Impairments
1793
+
1794
+ Blindness, low-level vision or color blindness are the common types of visual impairments. Screen magnifiers and the color blind mode are usually built-in features of the browsers whereas for people who rely on screen readers, page
1795
+ developers are required to make sure content is readable by the readers. Popular readers are
1796
+ [NVDA](https://www.nvaccess.org), [JAWS](https://www.freedomscientific.com/Products/software/JAWS/) and
1797
+ [ChromeVox](https://www.chromevox.com).
1798
+
1799
+ ### Hearing Impairments
1800
+
1801
+ Deafness or hearing loss refers to the inability to hear sounds totally or partially. People with hearing impairments use assistive devices however it may not be enough when interacting with a web page. Common implementation is
1802
+ providing textual alternatives, transcripts and captions for content with audio.
1803
+
1804
+ ### Mobility Impairments
1805
+
1806
+ People with mobility impairments have disabilities related to movement due to loss of a limb, paralysis or other varying reasons. Assistive technologies like a head pointer is a device to interact with a screen whereas keyboard or a
1807
+ trackpad remain as solutions for people who are not able to utilize a mouse.
1808
+
1809
+ ### Cognitive Impairments
1810
+
1811
+ Cognitive impairments have a wider range that includes people with learning disabilities, depression and dyslexia. A well designed content also leads to better user experience for people without disabilities so designing for cognitive
1812
+ impairments result in better design for any user.
1284
1813
 
1285
1814
  ## Semantichtml
1286
1815
 
1287
- HTML offers various element to organize content on a web page that screen readers are aware of. Preferring Semantic HTML for good semantics provide out of the box support for reader which is not possible when regular div elements with classes are used. Consider the following example that do not mean too much for readers. Same layout can be achieved using the semantic elements with screen reader support built-in.
1816
+ HTML offers various element to organize content on a web page that screen readers are aware of. Preferring Semantic HTML for good semantics provide out of the box support for reader which is not possible when regular
1817
+ `div` elements with classes are used. Consider the following example that do not mean too much for readers.
1818
+
1819
+ ```html
1820
+ <div class="header"/>
1821
+ <div class="header-text">Header></div>
1822
+ </div>
1823
+
1824
+ <div class="nav"></div>
1825
+
1826
+ <div class="main">
1827
+ <div class="content"></div>
1828
+ <div class="sidebar"></div>
1829
+ </div>
1830
+
1831
+ <div class="footer"></div>
1832
+ ```
1833
+
1834
+ Same layout can be achieved using the semantic elements with screen reader support built-in.
1835
+
1836
+ ```html
1837
+ <header>
1838
+ <h1>Header</h1>
1839
+ </header>
1840
+
1841
+ <nav></nav>
1842
+
1843
+ <main>
1844
+ <article></article>
1845
+ <aside></aside>
1846
+ </main>
1847
+
1848
+ <footer></footer>
1849
+ ```
1288
1850
 
1289
1851
  ## Waiaria
1290
1852
 
1291
- ARIA refers to "Accessible Rich Internet Applications" is a suite to fill the gap where semantic HTML is inadequate. These cases are mainly related to rich UI components/widgets. Although browser support for rich UI components such as a datepicker or colorpicker has been improved over the past years many web developers still utilize UI components derived from standard HTML elements created by them or by other projects like ExhaustiveUI. These types of components must provide keyboard and screen reader support, the latter case is where the WAI-ARIA is utilized. ARIA consists of roles, properties and attributes. Roles define what the element is mainly used for e.g. checkbox , dialog , tablist whereas States and Properties define the metadata of the element like aria-checked , aria-disabled . Consider the following case of a native checkbox. It has built-in keyboard and screen reader support. A fancy checkbox with css animations might look more appealing but accessibility might be lacking. Checkbox below may display a checked font icon with animations however it is not tabbable, cannot be checked with space key and cannot be read by a reader. One alternative is using ARIA roles for readers and use javascript for keyboard support. Notice the usage of aria-labelledby as a replacement of the label tag with for. However the best practice is combining semantic HTML for accessibility while keeping the design for UX. This approach involves hiding a native checkbox for accessibility and using javascript events to update its state. Notice the usage of p-hidden-accessible that hides the elements from the user but not from the screen reader. A working sample is the ExhaustiveUI checkbox that is tabbable, keyboard accessible and is compliant with a screen reader. Instead of ARIA roles it relies on a hidden native checkbox. Remember Me
1853
+ ARIA refers to "Accessible Rich Internet Applications" is a suite to fill the gap where semantic HTML is inadequate. These cases are mainly related to rich UI components/widgets. Although browser support for rich UI components such as
1854
+ a datepicker or colorpicker has been improved over the past years many web developers still utilize UI components derived from standard HTML elements created by them or by other projects like ExhaustiveUI. These types of components
1855
+ must provide keyboard and screen reader support, the latter case is where the WAI-ARIA is utilized.
1856
+
1857
+ ARIA consists of roles, properties and attributes. **Roles** define what the element is mainly used for e.g. `checkbox`, `dialog`, `tablist` whereas **States** and **Properties** define the metadata of the
1858
+ element like `aria-checked`, `aria-disabled`.
1859
+
1860
+ Consider the following case of a native checkbox. It has built-in keyboard and screen reader support.
1861
+
1862
+ ```html
1863
+ <input type="checkbox" value="Prime" name="ui" checked/>
1864
+ ```
1865
+
1866
+ A fancy checkbox with css animations might look more appealing but accessibility might be lacking. Checkbox below may display a checked font icon with animations however it is not tabbable, cannot be checked with space key and cannot
1867
+ be read by a reader.
1868
+
1869
+ ```html
1870
+ <div class="fancy-checkbox">
1871
+ <i *ngIf="checked" class="checked-icon"></i>
1872
+ </div>
1873
+ ```
1874
+
1875
+ One alternative is using ARIA roles for readers and use javascript for keyboard support. Notice the usage of
1876
+ `aria-labelledby` as a replacement of the `label` tag with for.
1877
+
1878
+ ```html
1879
+ <span id="chk-label">Remember Me></span>
1880
+ <div class="fancy-checkbox" role="checkbox" aria-checked="false" tabindex="0" aria-labelledby="chk-label" (click)="toggle()" (keydown)="onKeyDown($event)">
1881
+ <i *ngIf="checked" class="checked-icon"></i>
1882
+ </div>
1883
+ ```
1884
+
1885
+ However the best practice is combining semantic HTML for accessibility while keeping the design for UX. This approach involves hiding a native checkbox for accessibility and using javascript events to update its state. Notice the
1886
+ usage of
1887
+ `p-hidden-accessible`
1888
+ that hides the elements from the user but not from the screen reader.
1889
+
1890
+ ```html
1891
+ <label for="chkbox">Remember Me></label>
1892
+ <div class="fancy-checkbox" (click)="toggle()">
1893
+ <input class="p-hidden-accessible" type="checkbox" id="chkbox" (focus)="updateParentVisuals()" (blur)="updateParentVisuals()" (keydown)="$event.keyCode === 32 && updateParentVisuals()">
1894
+ <i *ngIf="checked" class="checked-icon"></i>
1895
+ </div>
1896
+ ```
1897
+
1898
+ A working sample is the ExhaustiveUI checkbox that is tabbable, keyboard accessible and is compliant with a screen reader. Instead of ARIA roles it relies on a hidden native checkbox.
1899
+
1900
+ Remember Me
1292
1901
 
1293
1902
  ## Wcag
1294
1903
 
1295
- WCAG refers to Web Content Accessibility Guideline , a standard managed by the WAI (Web Accessibility Initiative) of W3C (World Wide Web Consortium). WCAG consists of recommendations for making the web content more accessible. ExhaustiveUI components aim high level of WCAG compliancy in the near future. Various countries around the globe have governmental policies regarding web accessibility as well. Most well known of these are Section 508 in the US and Web Accessibility Directive of the European Union.
1904
+ [WCAG](https://www.w3.org/WAI/standards-guidelines/wcag/) refers to **Web Content Accessibility Guideline**, a standard managed by the WAI (Web Accessibility Initiative) of W3C (World Wide
1905
+ Web Consortium). WCAG consists of recommendations for making the web content more accessible. ExhaustiveUI components aim high level of WCAG compliancy in the near future.
1906
+
1907
+ Various countries around the globe have governmental policies regarding web accessibility as well. Most well known of these are [Section 508](https://www.section508.gov/manage/laws-and-policies/) in the US and
1908
+ [Web Accessibility Directive](https://digital-strategy.ec.europa.eu/en/policies/web-accessibility) of the European Union.
1296
1909
 
1297
1910
  ---
1298
1911
 
@@ -1302,15 +1915,39 @@ Built-in CSS animations for ExhaustiveUI components.
1302
1915
 
1303
1916
  ## Anchoredoverlays
1304
1917
 
1305
- Anchored overlays are the components that have a floating ui positioned relatively to another element such as Select, Popover. The enter and leave animations are defined with the .p-anchored-overlay-enter-active and .p-anchored-overlay-leave-active classes.
1918
+ Anchored overlays are the components that have a floating ui positioned relatively to another element such as Select, Popover. The enter and leave animations are defined with the `.p-anchored-overlay-enter-active` and
1919
+ `.p-anchored-overlay-leave-active`
1920
+ classes.
1306
1921
 
1307
1922
  ## Collapsibles
1308
1923
 
1309
- Collapsible components have a content that is toggleable including Accordion, Panel, Fieldset, Stepper and PanelMenu. The enter and leave animations are defined with the .p-collapsible-enter-active and .p-collapsible-leave-active classes. Header I Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Header II Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Consectetur, adipisci velit, sed quia non numquam eius modi. Header III Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Consectetur, adipisci velit, sed quia non numquam eius modi.
1924
+ Collapsible components have a content that is toggleable including Accordion, Panel, Fieldset, Stepper and PanelMenu. The enter and leave animations are defined with the `.p-collapsible-enter-active` and
1925
+ `.p-collapsible-leave-active`
1926
+ classes.
1927
+
1928
+ Header I
1929
+
1930
+ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
1931
+ commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim
1932
+ id est laborum.
1933
+
1934
+ Header II
1935
+
1936
+ Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
1937
+ Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Consectetur, adipisci velit, sed quia non numquam eius modi.
1938
+
1939
+ Header III
1940
+
1941
+ Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
1942
+ Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Consectetur, adipisci velit, sed quia non numquam eius modi.
1310
1943
 
1311
1944
  ## Dialog
1312
1945
 
1313
- Overlays such as Dialog and Drawer are positioned relative to the viewport and have their own animations. Update your information. Username Email
1946
+ Overlays such as Dialog and Drawer are positioned relative to the viewport and have their own animations.
1947
+
1948
+ Update your information.
1949
+ Username
1950
+ Email
1314
1951
 
1315
1952
  ## Disable
1316
1953
 
@@ -1318,11 +1955,92 @@ Individual animations can be reduced and even disabled completely using the anim
1318
1955
 
1319
1956
  ## Introduction
1320
1957
 
1321
- Various ExhaustiveUI Components utilize native CSS animations to provide an enhanced user experience. The default animations are based on the best practices recommended by the usability experts. In case you need to customize the default animations, this documentation covers the entire set of built-in animations. Animations are defined using a combination of style classes and keyframes. The ⁠ .{classname}-enter-active and ⁠ .{classname}-leave-active classes specify the animation name, duration, and easing function. You can customize animations globally by overriding the default animation classes, affecting all components. Alternatively, you can apply scoped classes to individual components to modify their animations independently. For demo purposes, this second approach is used throughout the next sections.
1958
+ Various ExhaustiveUI Components utilize native CSS animations to provide an enhanced user experience. The default animations are based on the best practices recommended by the usability experts. In case you need to customize the
1959
+ default animations, this documentation covers the entire set of built-in animations.
1960
+
1961
+ Animations are defined using a combination of style classes and keyframes. The ⁠`.{classname}-enter-active` and ⁠`.{classname}-leave-active` classes specify the animation name, duration, and easing
1962
+ function. You can customize animations globally by overriding the default animation classes, affecting all components. Alternatively, you can apply scoped classes to individual components to modify their animations independently. For
1963
+ demo purposes, this second approach is used throughout the next sections.
1322
1964
 
1323
1965
  ## Reference
1324
1966
 
1325
- List of class names of the CSS animations used by the components. Component Enter Class Leave Class Accordion .p-collapsible-enter-active .p-collapsible-leave-active AutoComplete .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active CascadeSelect .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active ColorPicker .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active ConfirmPopup .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active ContextMenu .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active DatePicker .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Dialog .p-dialog-enter-active .p-dialog-leave-active Drawer .p-drawer-enter-active .p-drawer-leave-active Fieldset .p-collapsible-enter-active .p-collapsible-leave-active Galleria .p-galleria-enter-active .p-galleria-leave-active Image .p-image-original-enter-active .p-image-original-leave-active Menu .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Message .p-message-enter-active .p-message-leave-active Modal Masks .p-overlay-mask-enter-active .p-overlay-mask-leave-active MultiSelect .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Panel .p-collapsible-enter-active .p-collapsible-leave-active PanelMenu .p-collapsible-enter-active .p-collapsible-leave-active Password .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Select .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Stepper .p-collapsible-enter-active .p-collapsible-leave-active TieredMenu .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active Toast .p-toast-message-enter-active .p-toast-message-leave-active TreeSelect .p-anchored-overlay-enter-active .p-anchored-overlay-leave-active
1967
+ List of class names of the CSS animations used by the components.
1968
+
1969
+ Component
1970
+ Enter Class
1971
+ Leave Class
1972
+ `Accordion`
1973
+ .p-collapsible-enter-active
1974
+ .p-collapsible-leave-active
1975
+ `AutoComplete`
1976
+ .p-anchored-overlay-enter-active
1977
+ .p-anchored-overlay-leave-active
1978
+ `CascadeSelect`
1979
+ .p-anchored-overlay-enter-active
1980
+ .p-anchored-overlay-leave-active
1981
+ `ColorPicker`
1982
+ .p-anchored-overlay-enter-active
1983
+ .p-anchored-overlay-leave-active
1984
+ `ConfirmPopup`
1985
+ .p-anchored-overlay-enter-active
1986
+ .p-anchored-overlay-leave-active
1987
+ `ContextMenu`
1988
+ .p-anchored-overlay-enter-active
1989
+ .p-anchored-overlay-leave-active
1990
+ `DatePicker`
1991
+ .p-anchored-overlay-enter-active
1992
+ .p-anchored-overlay-leave-active
1993
+ `Dialog`
1994
+ .p-dialog-enter-active
1995
+ .p-dialog-leave-active
1996
+ `Drawer`
1997
+ .p-drawer-enter-active
1998
+ .p-drawer-leave-active
1999
+ `Fieldset`
2000
+ .p-collapsible-enter-active
2001
+ .p-collapsible-leave-active
2002
+ `Galleria`
2003
+ .p-galleria-enter-active
2004
+ .p-galleria-leave-active
2005
+ `Image`
2006
+ .p-image-original-enter-active
2007
+ .p-image-original-leave-active
2008
+ `Menu`
2009
+ .p-anchored-overlay-enter-active
2010
+ .p-anchored-overlay-leave-active
2011
+ `Message`
2012
+ .p-message-enter-active
2013
+ .p-message-leave-active
2014
+ `Modal Masks`
2015
+ .p-overlay-mask-enter-active
2016
+ .p-overlay-mask-leave-active
2017
+ `MultiSelect`
2018
+ .p-anchored-overlay-enter-active
2019
+ .p-anchored-overlay-leave-active
2020
+ `Panel`
2021
+ .p-collapsible-enter-active
2022
+ .p-collapsible-leave-active
2023
+ `PanelMenu`
2024
+ .p-collapsible-enter-active
2025
+ .p-collapsible-leave-active
2026
+ `Password`
2027
+ .p-anchored-overlay-enter-active
2028
+ .p-anchored-overlay-leave-active
2029
+ `Select`
2030
+ .p-anchored-overlay-enter-active
2031
+ .p-anchored-overlay-leave-active
2032
+ `Stepper`
2033
+ .p-collapsible-enter-active
2034
+ .p-collapsible-leave-active
2035
+ `TieredMenu`
2036
+ .p-anchored-overlay-enter-active
2037
+ .p-anchored-overlay-leave-active
2038
+ `Toast`
2039
+ .p-toast-message-enter-active
2040
+ .p-toast-message-leave-active
2041
+ `TreeSelect`
2042
+ .p-anchored-overlay-enter-active
2043
+ .p-anchored-overlay-leave-active
1326
2044
 
1327
2045
  ---
1328
2046
 
@@ -1332,7 +2050,10 @@ Right-to-left support for ExhaustiveUI components.
1332
2050
 
1333
2051
  ## Configuration
1334
2052
 
1335
- The ExhaustiveUI components natively support Right-to-Left (RTL) text direction through a modern CSS implementation utilizing FlexBox and classes like *-inline-start and *-block-end . Consequently, no JavaScript configuration is necessary; setting the document's text direction to RTL is sufficient to enable this feature. The RTL setting can either be set using the dir attribute or with the direction style property.
2053
+ The ExhaustiveUI components natively support Right-to-Left (RTL) text direction through a modern CSS implementation utilizing FlexBox and classes like `*-inline-start` and `*-block-end`. Consequently, no JavaScript
2054
+ configuration is necessary; setting the document's text direction to RTL is sufficient to enable this feature.
2055
+
2056
+ The RTL setting can either be set using the `dir` attribute or with the `direction` style property.
1336
2057
 
1337
2058
  ## Limitations
1338
2059
 
@@ -1346,19 +2067,56 @@ Moving from PrimeFlex to Tailwind CSS.
1346
2067
 
1347
2068
  ## Compatibility
1348
2069
 
1349
- If you are staying on PrimeFlex for now, ExhaustiveUI pairs with PrimeFlex v4 — the same combination that worked with PrimeNG v18 and newer, since the styling architecture is unchanged. PrimeFlex v3 targeted the older PrimeNG releases and is not a supported pairing here. Neither version is tested against ExhaustiveUI releases, so treat this as "should work", not as a supported configuration. The migration below is the path we actually maintain.
2070
+ If you are staying on PrimeFlex for now, ExhaustiveUI pairs with PrimeFlex v4 — the same combination that worked with PrimeNG v18 and newer, since the styling architecture is unchanged. PrimeFlex v3 targeted the older PrimeNG releases
2071
+ and is not a supported pairing here.
2072
+
2073
+ Neither version is tested against ExhaustiveUI releases, so treat this as "should work", not as a supported configuration. The migration below is the path we actually maintain.
1350
2074
 
1351
2075
  ## Migration
1352
2076
 
1353
- PrimeFlex class names map closely onto Tailwind's, so most of the work is mechanical. PrimeTek's primeclt ships a pf2tw command that does the conversion, and it works on any codebase — it rewrites class names and does not care which component library you use. Run pf2tw in a directory containing the files to convert. pf2tw was written for Tailwind v3. Tailwind v4 renamed a few of the utilities it produces, for example shadow-sm to shadow-xs , rounded to rounded-sm and flex-grow to grow . On Tailwind v4, check the converted classes against the renamed utilities list of the Tailwind upgrade guide. A handful of PrimeFlex classes have no Tailwind counterpart and are left alone. Replace them with flexbox or grid utilities by hand: formgrid formgroup formgroup-inline col col-fixed field field-checkbox field-radiobutton reset
2077
+ PrimeFlex class names map closely onto Tailwind's, so most of the work is mechanical. PrimeTek's
2078
+ [primeclt](https://www.npmjs.com/package/primeclt) ships a `pf2tw` command that does the conversion, and it works on any codebase — it rewrites class names and does not care
2079
+ which component library you use.
2080
+
2081
+ ```bash
2082
+ npm install -g primeclt
2083
+ ```
2084
+
2085
+ Run `pf2tw` in a directory containing the files to convert.
2086
+
2087
+ ```bash
2088
+ prime pf2tw
2089
+ ```
2090
+
2091
+ `pf2tw` was written for Tailwind v3. Tailwind v4 renamed a few of the utilities it produces, for example `shadow-sm` to `shadow-xs`, `rounded` to `rounded-sm` and `flex-grow` to `grow`. On Tailwind
2092
+ v4, check the converted classes against the [renamed utilities](https://tailwindcss.com/docs/upgrade-guide#renamed-utilities) list of the Tailwind upgrade guide.
2093
+
2094
+ A handful of PrimeFlex classes have no Tailwind counterpart and are left alone. Replace them with flexbox or grid utilities by hand:
2095
+
2096
+ - formgrid
2097
+ - formgroup
2098
+ - formgroup-inline
2099
+ - col
2100
+ - col-fixed
2101
+ - field
2102
+ - field-checkbox
2103
+ - field-radiobutton
2104
+ - reset
1354
2105
 
1355
2106
  ## Overview
1356
2107
 
1357
- PrimeFlex was PrimeTek's lightweight CSS utility library, designed to accompany PrimeNG. PrimeTek stopped maintaining it before the relicensing, on the grounds that most applications already bring their own utility layer — Tailwind, Bootstrap or something in-house — and a second one only overlaps with it. ExhaustiveUI does not maintain PrimeFlex either, and for the same reason. Nothing in this library depends on it, and no component requires it. If your application already uses PrimeFlex it will keep working, but it will not receive updates from us, and we suggest moving to Tailwind CSS.
2108
+ [PrimeFlex](https://primeflex.org) was PrimeTek's lightweight CSS utility library, designed to accompany PrimeNG. PrimeTek stopped maintaining it before the relicensing, on the
2109
+ grounds that most applications already bring their own utility layer — Tailwind, Bootstrap or something in-house — and a second one only overlaps with it.
2110
+
2111
+ ExhaustiveUI does not maintain PrimeFlex either, and for the same reason. Nothing in this library depends on it, and no component requires it. If your application already uses PrimeFlex it will keep working, but it will not receive
2112
+ updates from us, and we suggest moving to Tailwind CSS.
1358
2113
 
1359
2114
  ## Tailwindcss
1360
2115
 
1361
- Tailwind CSS is the replacement we suggest. This documentation site is itself built with it, and we publish @exhaustive-ui/tailwindcss for first-class integration — a plugin that teaches Tailwind about the theme's design tokens and puts the component styles in a cascade layer you can override cleanly. See the Tailwind CSS guide for setup with either Tailwind v3 or v4, and the next section for converting existing PrimeFlex classes.
2116
+ Tailwind CSS is the replacement we suggest. This documentation site is itself built with it, and we publish `@exhaustive-ui/tailwindcss` for first-class integration — a plugin that teaches Tailwind about the theme's design
2117
+ tokens and puts the component styles in a cascade layer you can override cleanly.
2118
+
2119
+ See the [Tailwind CSS guide](https://exhaustive-ui.com/tailwind) for setup with either Tailwind v3 or v4, and the next section for converting existing PrimeFlex classes.
1362
2120
 
1363
2121
  ---
1364
2122
 
@@ -1366,29 +2124,97 @@ Tailwind CSS is the replacement we suggest. This documentation site is itself bu
1366
2124
 
1367
2125
  Why ExhaustiveUI exists, what it commits to, and where it stops.
1368
2126
 
1369
- ## Governance
2127
+ ## Why This Fork Exists
2128
+
2129
+ In June 2026 PrimeTek archived the PrimeNG repository and moved future major versions, starting with v22, to a commercial license. They explained their reasoning in
2130
+ [their own announcement](https://primeui.dev/nextchapter), and it is worth reading. Maintaining a component library of this size for a decade, largely for free, is genuinely hard,
2131
+ and we do not think the decision was made lightly.
1370
2132
 
1371
- Everything happens in the open, in the repository . There is no private roadmap and no internal issue tracker. What you see in the issues, the discussions and the roadmap is the whole plan. Contributors earn commit access by contributing — the contribution guide describes the Contributor and Committer roles and roughly what it takes to reach them. We would rather grow the number of people who can merge a fix than route everything through one person. Breaking changes are avoided within a major and documented when a major requires them. Where we inherited a name that no longer fits — the CSS cascade layer, the package scope, the icon library — we changed it once, at v1, with a migration schematic, rather than dripping renames across releases.
2133
+ It did, however, leave a lot of applications on a library with no further open source releases. ExhaustiveUI exists for those applications. It is a community fork of the last MIT licensed version of PrimeNG, v21, and it stays MIT.
1372
2134
 
1373
- ## Limits
2135
+ This is not an official fork and it is not endorsed by PrimeTek. It is a separate repository, seeded with PrimeNG's code and history, maintained by people who depend on it.
1374
2136
 
1375
- Naming the limits is what makes the commitments above worth anything. Here is what ExhaustiveUI is not. There is no commercial support No SLA, no support contract, no guaranteed response time. Issues and discussions are answered by volunteers when they have time. If your organisation needs contractual guarantees, this project cannot provide them and you should plan accordingly. There are no premium templates, blocks or design tooling PrimeTek's application templates, block library and visual theme designer are their commercial products. They are not part of what was MIT licensed, so they are not part of this fork and will not be reimplemented. Theming here means editing preset objects in code, which is documented in full. We are not chasing feature parity with PrimeNG v22 and beyond PrimeNG continues under its own license and its own roadmap. ExhaustiveUI diverges from v21 forward. Some things they add, we will not have. Some things we fix, they will not. Treat the two as separate libraries that share an ancestor, not as a free copy of a paid product. The bus factor is real This is maintained by a small group of people in their own time. We would rather say that plainly than imply a larger organisation stands behind it. The best way to change that number is to contribute .
2137
+ ## What We Commit To
1376
2138
 
1377
- ## Origin
2139
+ Four commitments, in the order we would want to read them if we were choosing a dependency:
1378
2140
 
1379
- In June 2026 PrimeTek archived the PrimeNG repository and moved future major versions, starting with v22, to a commercial license. They explained their reasoning in their own announcement , and it is worth reading. Maintaining a component library of this size for a decade, largely for free, is genuinely hard, and we do not think the decision was made lightly. It did, however, leave a lot of applications on a library with no further open source releases. ExhaustiveUI exists for those applications. It is a community fork of the last MIT licensed version of PrimeNG, v21, and it stays MIT. This is not an official fork and it is not endorsed by PrimeTek. It is a separate repository, seeded with PrimeNG's code and history, maintained by people who depend on it.
2141
+ ### MIT, with no second tier
1380
2142
 
1381
- ## Promises
2143
+ Every package we publish is MIT licensed. There is no paid edition, no enterprise build, no feature held back behind a subscription, and no plan to introduce one. If that ever changed, it would be a fork of this project rather than a
2144
+ relicensing of it, because the code we inherited is MIT and so is everything we add to it.
1382
2145
 
1383
- Four commitments, in the order we would want to read them if we were choosing a dependency: MIT, with no second tier Every package we publish is MIT licensed. There is no paid edition, no enterprise build, no feature held back behind a subscription, and no plan to introduce one. If that ever changed, it would be a fork of this project rather than a relicensing of it, because the code we inherited is MIT and so is everything we add to it. We track Angular Our release cadence follows Angular's. When a new Angular major lands, the priority is a compatible ExhaustiveUI major — before new features, before refactors. Staying upgradeable is the single most valuable thing a component library can do for the applications built on it. Bugs before features We inherited a large backlog along with the code. Fixing what is broken ranks above adding what is missing. Feature requests are triaged and welcome, but they generally ship when someone in the community implements them. No surprises in your bundle The library sends no telemetry, phones no home, and requires no account or key to use. What you install is what runs.
2146
+ ### We track Angular
2147
+
2148
+ Our release cadence follows Angular's. When a new Angular major lands, the priority is a compatible ExhaustiveUI major — before new features, before refactors. Staying upgradeable is the single most valuable thing a component library
2149
+ can do for the applications built on it.
2150
+
2151
+ ### Bugs before features
2152
+
2153
+ We inherited a large backlog along with the code. Fixing what is broken ranks above adding what is missing. Feature requests are triaged and welcome, but they generally ship when someone in the community implements them.
2154
+
2155
+ ### No surprises in your bundle
2156
+
2157
+ The library sends no telemetry, phones no home, and requires no account or key to use. What you install is what runs.
2158
+
2159
+ ## What We Do Not Do
2160
+
2161
+ Naming the limits is what makes the commitments above worth anything. Here is what ExhaustiveUI is not.
2162
+
2163
+ ### There is no commercial support
2164
+
2165
+ No SLA, no support contract, no guaranteed response time. Issues and discussions are answered by volunteers when they have time. If your organisation needs contractual guarantees, this project cannot provide them and you should plan
2166
+ accordingly.
2167
+
2168
+ ### There are no premium templates, blocks or design tooling
2169
+
2170
+ PrimeTek's application templates, block library and visual theme designer are their commercial products. They are not part of what was MIT licensed, so they are not part of this fork and will not be reimplemented. Theming here means
2171
+ editing preset objects in code, which is documented in full.
2172
+
2173
+ ### We are not chasing feature parity with PrimeNG v22 and beyond
2174
+
2175
+ PrimeNG continues under its own license and its own roadmap. ExhaustiveUI diverges from v21 forward. Some things they add, we will not have. Some things we fix, they will not. Treat the two as separate libraries that share an
2176
+ ancestor, not as a free copy of a paid product.
2177
+
2178
+ ### The bus factor is real
2179
+
2180
+ This is maintained by a small group of people in their own time. We would rather say that plainly than imply a larger organisation stands behind it. The best way to change that number is to
2181
+ [contribute](https://github.com/e-xiste/exhaustive-ui).
2182
+
2183
+ ## How Decisions Are Made
2184
+
2185
+ Everything happens in the open, in the [repository](https://github.com/e-xiste/exhaustive-ui). There is no private roadmap and no internal issue tracker. What you see in the issues,
2186
+ the discussions and the [roadmap](https://exhaustive-ui.com/roadmap) is the whole plan.
2187
+
2188
+ Contributors earn commit access by contributing — the [contribution guide](https://exhaustive-ui.com/contribution) describes the Contributor and Committer roles and roughly what it takes to reach them. We would rather
2189
+ grow the number of people who can merge a fix than route everything through one person.
2190
+
2191
+ Breaking changes are avoided within a major and documented when a major requires them. Where we inherited a name that no longer fits — the CSS cascade layer, the package scope, the icon library — we changed it once, at v1, with a
2192
+ migration schematic, rather than dripping renames across releases.
2193
+
2194
+ ## PrimeNG and PrimeTek
2195
+
2196
+ ExhaustiveUI is not affiliated with, endorsed by, or sponsored by PrimeTek. PrimeNG, PrimeFaces, PrimeReact, PrimeVue and PrimeFlex are their trademarks. The rename from the inherited names — the packages, the CSS layer, the icon
2197
+ library — is a trademark matter, not a technical one, and it is why we ship a [migration schematic](https://exhaustive-ui.com/migration/primeng) rather than asking you to rewrite imports by hand.
2198
+
2199
+ References to PrimeNG remain throughout this documentation and the source, and they are deliberate. Attribution is the point: this library is PrimeTek's decade of work plus whatever the community adds on top. Pretending otherwise
2200
+ would be both dishonest and useless to anyone trying to find their way around a familiar API.
2201
+
2202
+ The code we forked was published under the MIT license, and we distribute it under those same terms, with the original copyright notices intact.
1384
2203
 
1385
2204
  ## Sustainability
1386
2205
 
1387
- The honest answer to "how is this funded" is: it mostly is not. e-xiste covers the hosting and the domain; the work is volunteered. That is a fragile arrangement, and it is the main risk to this project — larger than any technical risk we can see today. The things that actually help, roughly in order of impact: Reproducing and triaging issues. A bug with a minimal reproduction is several times more likely to get fixed. Sending pull requests, especially for issues labelled help-needed . Answering questions in discussions, so the same answer is not written five times. Improving this documentation. Every page has a source file and every fix is welcome. Telling your employer you depend on it. Sponsored maintenance time is worth more than any one-off donation. The contribution guide covers how to get started.
2206
+ The honest answer to "how is this funded" is: it mostly is not. e-xiste covers the hosting and the domain; the work is volunteered. That is a fragile arrangement, and it is the main risk to this project — larger than any technical
2207
+ risk we can see today.
2208
+
2209
+ The things that actually help, roughly in order of impact:
1388
2210
 
1389
- ## Trademark
2211
+ - Reproducing and triaging issues. A bug with a minimal reproduction is several times more likely to get fixed.
2212
+ - Sending pull requests, especially for issues labelled `help-needed`.
2213
+ - Answering questions in discussions, so the same answer is not written five times.
2214
+ - Improving this documentation. Every page has a source file and every fix is welcome.
2215
+ - Telling your employer you depend on it. Sponsored maintenance time is worth more than any one-off donation.
1390
2216
 
1391
- ExhaustiveUI is not affiliated with, endorsed by, or sponsored by PrimeTek. PrimeNG, PrimeFaces, PrimeReact, PrimeVue and PrimeFlex are their trademarks. The rename from the inherited names — the packages, the CSS layer, the icon library — is a trademark matter, not a technical one, and it is why we ship a migration schematic rather than asking you to rewrite imports by hand. References to PrimeNG remain throughout this documentation and the source, and they are deliberate. Attribution is the point: this library is PrimeTek's decade of work plus whatever the community adds on top. Pretending otherwise would be both dishonest and useless to anyone trying to find their way around a familiar API. The code we forked was published under the MIT license, and we distribute it under those same terms, with the original copyright notices intact.
2217
+ The [contribution guide](https://exhaustive-ui.com/contribution) covers how to get started.
1392
2218
 
1393
2219
  ---
1394
2220
 
@@ -1396,47 +2222,640 @@ ExhaustiveUI is not affiliated with, endorsed by, or sponsored by PrimeTek. Prim
1396
2222
 
1397
2223
  Licensing, migration from PrimeNG, the ecosystem, and how support works.
1398
2224
 
1399
- ## Ecosystem
2225
+ ## The Project
1400
2226
 
1401
- Do the PrimeNG themes work? The built-in presets do — Aura, Material, Lara and Nora ship in @exhaustive-ui/themes and are configured the same way. A preset you wrote yourself against PrimeNG v21 will work after the import paths are updated, which the migration schematic handles. What about the Theme Designer, templates and blocks? Those are PrimeTek's commercial products. They were never MIT licensed, so they are not part of this fork and we will not be reimplementing them. Theming in ExhaustiveUI means editing preset objects in code, which is documented in full under styled mode . What replaced PrimeIcons? OpenNG Icons , installed as @openng/icons . The pi pi-{icon} class names are unchanged, so templates do not need editing — only the package name and the stylesheet import, both of which the migration schematic rewrites. What about PrimeFlex? PrimeFlex is not maintained here. We suggest Tailwind CSS instead, and ship @exhaustive-ui/tailwindcss for first-class integration — see the Tailwind guide . The PrimeFlex guide covers moving across. Does ExhaustiveUI work with SSR? This documentation site is itself an Angular SSR application built on ExhaustiveUI, prerendered at build time. So yes, and any regression there tends to be noticed quickly.
2227
+ ### Is ExhaustiveUI free? Will it stay free?
1402
2228
 
1403
- ## Migration
2229
+ Yes, and yes. Every package is MIT licensed, and the code we forked was MIT too, so relicensing it is not something we could do even if we wanted to. There is no paid tier and none is planned. The
2230
+ [philosophy page](https://exhaustive-ui.com/philosophy) goes into what that does and does not buy you.
2231
+
2232
+ ### Is this an official PrimeNG fork? Are you affiliated with PrimeTek?
2233
+
2234
+ No. ExhaustiveUI is an independent community fork, not affiliated with, endorsed by, or sponsored by PrimeTek. It is a fork of
2235
+ [Optimus UI](https://github.com/openng-org/optimus-ui) (OpenNG), itself a repository seeded with PrimeNG's MIT licensed code and history, not a fork of the archived
2236
+ `primefaces/primeng` repository.
2237
+
2238
+ ### Which PrimeNG version is this forked from?
2239
+
2240
+ PrimeNG v21, the last version published under the MIT license, by way of Optimus UI v2. ExhaustiveUI v22 is that codebase, rebranded and migrated to the Angular Signals API, with the fixes that have landed since; its major version
2241
+ number follows Angular's.
2242
+
2243
+ ### Who maintains it, and how is it funded?
2244
+
2245
+ A small group of volunteers, with e-xiste covering hosting and the domain. We are deliberate about not implying more than that — see
2246
+ [sustainability](https://exhaustive-ui.com/philosophy) for the honest version and the ways that can change.
2247
+
2248
+ ### Why did the name change?
2249
+
2250
+ Trademark, twice over. PrimeNG, PrimeFaces and PrimeFlex are PrimeTek's marks, and Optimus UI is OpenNG's, so the packages and the CSS cascade layer needed a name of their own. That is also why the rename from PrimeNG is handled by a
2251
+ schematic rather than by asking you to rewrite imports by hand.
2252
+
2253
+ ## Compatibility & Migration
2254
+
2255
+ ### Which Angular versions are supported?
2256
+
2257
+ Angular v22: ExhaustiveUI v22 requires Angular v22. Our majors follow Angular's — when a new Angular major ships, a compatible ExhaustiveUI major is the first thing we work on. See the
2258
+ [version compatibility table](https://exhaustive-ui.com/migration/update) in the update guide.
2259
+
2260
+ ### How do I migrate from PrimeNG? Is it automatic?
2261
+
2262
+ Mostly, but not through `ng add`, which only sets up new projects and fails without changing anything when it finds an existing `primeng` dependency. Install `@exhaustive-ui/core`, then run
2263
+ `ng generate @exhaustive-ui/core:migrate-from-primeng` in a PrimeNG v21 workspace updated to Angular v22: packages swapped, imports rewritten, dependencies installed. It then prints a report of anything it could not rewrite,
2264
+ with file and line numbers. The [migration guide](https://exhaustive-ui.com/migration/primeng) covers the details and the manual cases.
2265
+
2266
+ ### I am on PrimeNG v20 or older. Can I migrate directly?
2267
+
2268
+ No. Upgrade to PrimeNG v21 first, using PrimeNG's own migration guides, then update Angular to v22 and run the schematic. The schematic checks the version and refuses rather than producing a half-migrated workspace.
2269
+
2270
+ ### I use Optimus UI. Can I switch?
2271
+
2272
+ Yes. ExhaustiveUI is a fork of Optimus UI, with the same components. On Optimus UI v2, run `ng generate @exhaustive-ui/core:migrate-from-optimus`: packages swapped, imports and configuration API renamed, CSS layer renamed,
2273
+ dependencies installed. The [Optimus UI migration guide](https://exhaustive-ui.com/migration/optimus) covers the steps and the v22 migrations that follow.
2274
+
2275
+ ### What happens to my PrimeNG license?
2276
+
2277
+ Nothing — it is unrelated. A PrimeNG v22 commercial license covers PrimeNG. ExhaustiveUI needs no license at all. If you hold a PrimeTek subscription for their templates or theme designer, those remain their products and do not carry
2278
+ over here.
2279
+
2280
+ ### I had an open PR on primefaces/primeng. Can I bring it here?
2281
+
2282
+ Yes, and we would like you to. Append `.patch` to your original pull request URL and apply it with `git am` — the contributing guide in the repository walks through it, including what to do when the patch no longer applies
2283
+ cleanly.
2284
+
2285
+ ### Can I run PrimeNG and ExhaustiveUI side by side?
2286
+
2287
+ Technically yes, since the package names and the CSS cascade layer differ, but you will ship two copies of the same components and two theme runtimes. Treat it as a temporary state during migration rather than a supported
2288
+ configuration.
2289
+
2290
+ ## Themes, Icons & Ecosystem
2291
+
2292
+ ### Do the PrimeNG themes work?
2293
+
2294
+ The built-in presets do — Aura, Material, Lara and Nora ship in `@exhaustive-ui/themes` and are configured the same way. A preset you wrote yourself against PrimeNG v21 will work after the import paths are updated, which the
2295
+ migration schematic handles.
2296
+
2297
+ ### What about the Theme Designer, templates and blocks?
2298
+
2299
+ Those are PrimeTek's commercial products. They were never MIT licensed, so they are not part of this fork and we will not be reimplementing them. Theming in ExhaustiveUI means editing preset objects in code, which is documented in
2300
+ full under [styled mode](https://exhaustive-ui.com/theming/styled).
2301
+
2302
+ ### What replaced PrimeIcons?
2303
+
2304
+ [OpenNG Icons](https://exhaustive-ui.com/icons), installed as `@openng/icons`. The `pi pi-{icon}` class names are unchanged, so templates do not need editing — only the package name and the
2305
+ stylesheet import, both of which the migration schematic rewrites.
2306
+
2307
+ ### What about PrimeFlex?
2308
+
2309
+ PrimeFlex is not maintained here. We suggest Tailwind CSS instead, and ship `@exhaustive-ui/tailwindcss` for first-class integration — see the [Tailwind guide](https://exhaustive-ui.com/tailwind). The
2310
+ [PrimeFlex guide](https://exhaustive-ui.com/guides/primeflex) covers moving across.
1404
2311
 
1405
- Which Angular versions are supported? Angular v22: ExhaustiveUI v22 requires Angular v22. Our majors follow Angular's — when a new Angular major ships, a compatible ExhaustiveUI major is the first thing we work on. See the version compatibility table in the update guide. How do I migrate from PrimeNG? Is it automatic? Mostly, but not through ng add , which only sets up new projects and fails without changing anything when it finds an existing primeng dependency. Install @exhaustive-ui/core , then run ng generate @exhaustive-ui/core:migrate-from-primeng in a PrimeNG v21 workspace updated to Angular v22: packages swapped, imports rewritten, dependencies installed. It then prints a report of anything it could not rewrite, with file and line numbers. The migration guide covers the details and the manual cases. I am on PrimeNG v20 or older. Can I migrate directly? No. Upgrade to PrimeNG v21 first, using PrimeNG's own migration guides, then update Angular to v22 and run the schematic. The schematic checks the version and refuses rather than producing a half-migrated workspace. What happens to my PrimeNG license? Nothing — it is unrelated. A PrimeNG v22 commercial license covers PrimeNG. ExhaustiveUI needs no license at all. If you hold a PrimeTek subscription for their templates or theme designer, those remain their products and do not carry over here. I had an open PR on primefaces/primeng. Can I bring it here? Yes, and we would like you to. Append .patch to your original pull request URL and apply it with git am — the contributing guide in the repository walks through it, including what to do when the patch no longer applies cleanly. Can I run PrimeNG and ExhaustiveUI side by side? Technically yes, since the package names and the CSS cascade layer differ, but you will ship two copies of the same components and two theme runtimes. Treat it as a temporary state during migration rather than a supported configuration.
2312
+ ### Does ExhaustiveUI work with SSR?
1406
2313
 
1407
- ## Project
2314
+ This documentation site is itself an Angular SSR application built on ExhaustiveUI, prerendered at build time. So yes, and any regression there tends to be noticed quickly.
1408
2315
 
1409
- Is ExhaustiveUI free? Will it stay free? Yes, and yes. Every package is MIT licensed, and the code we forked was MIT too, so relicensing it is not something we could do even if we wanted to. There is no paid tier and none is planned. The philosophy page goes into what that does and does not buy you. Is this an official PrimeNG fork? Are you affiliated with PrimeTek? No. ExhaustiveUI is an independent community fork, not affiliated with, endorsed by, or sponsored by PrimeTek. It is a fork of Optimus UI (OpenNG), itself a repository seeded with PrimeNG's MIT licensed code and history, not a fork of the archived primefaces/primeng repository. Which PrimeNG version is this forked from? PrimeNG v21, the last version published under the MIT license, by way of Optimus UI v2. ExhaustiveUI v22 is that codebase, rebranded and migrated to the Angular Signals API, with the fixes that have landed since; its major version number follows Angular's. Who maintains it, and how is it funded? A small group of volunteers, with e-xiste covering hosting and the domain. We are deliberate about not implying more than that — see sustainability for the honest version and the ways that can change. Why did the name change? Trademark, twice over. PrimeNG, PrimeFaces and PrimeFlex are PrimeTek's marks, and Optimus UI is OpenNG's, so the packages and the CSS cascade layer needed a name of their own. That is also why the rename from PrimeNG is handled by a schematic rather than by asking you to rewrite imports by hand.
2316
+ ## Support & Contributing
1410
2317
 
1411
- ## Support
2318
+ ### Is there commercial support?
1412
2319
 
1413
- Is there commercial support? No. There is no SLA, no support contract and no guaranteed response time. Issues and discussions are answered by volunteers when they have time. If your organisation needs contractual guarantees, this project cannot offer them. How do I report a bug? Open an issue on GitHub with a minimal reproduction — a StackBlitz from any demo on this site is ideal — plus your ExhaustiveUI, Angular and browser versions. A reproduction is the difference between a bug that gets fixed and one that sits in the backlog. How do I request a feature? Open a discussion . Requests are triaged and welcome, but in practice they ship when someone implements them. If it matters to you, the contribution guide is the fastest route. Where do I ask questions? GitHub Discussions is the primary place. There is no chat server; a written question with a reproduction gets a better answer than a real-time one. How does versioning work? Semantic versioning, with majors tracking Angular majors. Breaking changes are confined to majors and documented in the GitHub releases .
2320
+ No. There is no SLA, no support contract and no guaranteed response time. Issues and discussions are answered by volunteers when they have time. If your organisation needs contractual guarantees, this project cannot offer them.
2321
+
2322
+ ### How do I report a bug?
2323
+
2324
+ Open an issue on [GitHub](https://github.com/e-xiste/exhaustive-ui/issues) with a minimal reproduction — a StackBlitz from any demo on this site is ideal — plus your ExhaustiveUI,
2325
+ Angular and browser versions. A reproduction is the difference between a bug that gets fixed and one that sits in the backlog.
2326
+
2327
+ ### How do I request a feature?
2328
+
2329
+ Open a [discussion](https://github.com/e-xiste/exhaustive-ui/discussions). Requests are triaged and welcome, but in practice they ship when someone implements them. If it matters to
2330
+ you, the [contribution guide](https://exhaustive-ui.com/contribution) is the fastest route.
2331
+
2332
+ ### Where do I ask questions?
2333
+
2334
+ GitHub Discussions is the primary place. There is no chat server; a written question with a reproduction gets a better answer than a real-time one.
2335
+
2336
+ ### How does versioning work?
2337
+
2338
+ Semantic versioning, with majors tracking Angular majors. Breaking changes are confined to majors and documented in the
2339
+ [GitHub releases](https://github.com/e-xiste/exhaustive-ui/releases).
1414
2340
 
1415
2341
  ---
1416
2342
 
1417
2343
  # Update ExhaustiveUI
1418
2344
 
1419
- Updating with ng update, Angular version compatibility, and what changes in v22 (Signals API, OnPush, automated migrations).
2345
+ Updating with ng update, Angular version compatibility, and a summary of what changes in v22.
2346
+
2347
+ ## Overview
2348
+
2349
+ All `@exhaustive-ui/core` packages — the components, themes, locale definitions, Tailwind CSS plugin and their internal dependencies — are versioned and released together, so an update always moves the whole suite to a single
2350
+ new version. ExhaustiveUI supports `ng update`, the Angular CLI's own update mechanism, which bumps every installed ExhaustiveUI package in one step and runs any automated code migrations shipped with the new version.
2351
+
2352
+ Major versions follow Angular's: when a new Angular major ships, a matching ExhaustiveUI major is released for it. Minor and patch releases stay within the same Angular major and are drop-in updates.
2353
+
2354
+ This page is about updating a project that already uses ExhaustiveUI. To move an existing workspace across, see the guides for
2355
+ [PrimeNG](https://exhaustive-ui.com/migration/primeng) and [Optimus UI](https://exhaustive-ui.com/migration/optimus) instead.
2356
+
2357
+ ## Updating
2358
+
2359
+ Run `ng update` without arguments at any time to list the updates available in your workspace, ExhaustiveUI included.
2360
+
2361
+ ```bash
2362
+ ng update
2363
+ ```
2364
+
2365
+ To update within the current major, pass the main package. The Angular CLI resolves the rest: `@exhaustive-ui/core` declares all its companion packages as a group, so every installed `@exhaustive-ui/*` package —
2366
+ themes, locale, Tailwind CSS plugin and the internal runtime packages — is updated together and the suite cannot end up on mixed versions.
2367
+
2368
+ ```bash
2369
+ ng update @exhaustive-ui/core
2370
+ ```
2371
+
2372
+ Like any `ng update` run, the command expects a clean git working tree so its changes can be reviewed or reverted in isolation — commit or stash your work first.
2373
+
2374
+ ## Angular Version Compatibility
2375
+
2376
+ Each ExhaustiveUI major targets a single Angular major.
2377
+
2378
+ To move to a new major, update Angular first — the [Angular update guide](https://angular.dev/update-guide) covers that step — then update ExhaustiveUI to the matching major by
2379
+ passing the target version. For example, once Angular v23 and ExhaustiveUI v23 are out, from v22:
2380
+
2381
+ ```bash
2382
+ ng update @angular/core@23 @angular/cli@23
2383
+ ng update @exhaustive-ui/core@23
2384
+ ```
2385
+
2386
+ Review the release notes of the target version for breaking changes before you start.
2387
+
2388
+ ## Updating to v22
2389
+
2390
+ ExhaustiveUI v22 is the first major of the fork. It requires Angular 22 and moves the whole library to the Angular Signals API. Templates keep working as before; code that reaches into a component instance reads inputs with a call and
2391
+ writes two-way properties with `.set()`, and components use OnPush change detection. `ng update` applies nine migrations to templates and code and reports what it left for review.
2392
+
2393
+ ```bash
2394
+ ng update @angular/core@22 @angular/cli@22
2395
+ ng update @exhaustive-ui/core@22
2396
+ ```
2397
+
2398
+ The [migration guide to v22](https://exhaustive-ui.com/migration/v22) covers the update steps from an ExhaustiveUI prerelease, PrimeNG v21 or Optimus UI, each migration and its report, the code changes, and the behavior
2399
+ and type changes.
2400
+
2401
+ ## Release Notes
2402
+
2403
+ Every version is published with its notes on the [GitHub releases page](https://github.com/e-xiste/exhaustive-ui/releases), covering new features, fixes and any breaking changes or
2404
+ manual steps a release requires. Check the notes for the target version before a major update.
2405
+
2406
+ ---
2407
+
2408
+ # Migrating from PrimeNG
2409
+
2410
+ Moving a PrimeNG v21 application to ExhaustiveUI: the migrate-from-primeng schematic, what it changes (packages, imports, configuration API, icons, CSS layer), the manual checks and the v22 migrations.
2411
+
2412
+ ## Overview
2413
+
2414
+ ExhaustiveUI is an MIT fork of PrimeNG v21, the last PrimeNG release published under the MIT license, by way of Optimus UI. The components, their selectors, the `p-*` CSS classes, the design tokens and the `pi pi-*` icon
2415
+ classes are the same, so a PrimeNG v21 application moves across in two parts:
2416
+
2417
+ 1. **The switch**: other package names, a configuration API named after ExhaustiveUI, another icon package and another default CSS layer name. The `migrate-from-primeng` schematic does it.
2418
+ 2. **The v22 changes**: Angular 22, the Signals API, OnPush and the API cleanup of ExhaustiveUI v22. The `ng update` migrations do most of it, and the [migration guide to v22](https://exhaustive-ui.com/migration/v22) covers the rest.
2419
+
2420
+ No license is needed. A PrimeTek license or subscription for PrimeNG, its templates or its theme designer does not carry over, and is not required.
2421
+
2422
+ ## Before you start
2423
+
2424
+ - **PrimeNG v21.** ExhaustiveUI shares its API. On v20 or older, upgrade to v21 first with PrimeNG's own update guides; the schematic checks the installed version and stops otherwise. On PrimeNG v22, the schematic runs, but the features PrimeNG added after v21 have no ExhaustiveUI equivalent: check the compiler errors and the report.
2425
+ - **A clean git working tree**, so every change can be reviewed and reverted on its own, and a build and test run that passes before you start.
2426
+ - **PrimeFlex**, if the project uses it, is not migrated by this schematic. Run `migrate-from-primeflex` afterwards to move its classes to Tailwind CSS; the schematic reminds you when it finds PrimeFlex.
2427
+
2428
+ ## Migration steps
2429
+
2430
+ 1. Update Angular to 22. PrimeNG v21 declares Angular 21 as its peer dependency, so the Angular CLI refuses the update while `primeng` is installed: pass `--force`. The next step removes `primeng`.
2431
+ 2. Install ExhaustiveUI and run the `migrate-from-primeng` schematic. It rewrites the workspace, then installs the new dependencies.
2432
+ 3. Run the v22 migrations. The workspace did not go through `ng update`, so they are run explicitly, from the version before v22.
2433
+ 4. Read both reports, fix the compiler errors, then build and run your tests.
2434
+
2435
+ ```bash
2436
+ ng update @angular/core@22 @angular/cli@22 --force
2437
+ npm install @exhaustive-ui/core@22
2438
+ ng generate @exhaustive-ui/core:migrate-from-primeng
2439
+ ng update @exhaustive-ui/core --migrate-only --from=3.0.0
2440
+ ```
2441
+
2442
+ The schematic takes two options: `--skip-install` leaves the install to you, and `--force` skips the PrimeNG version check.
2443
+
2444
+ ## What the schematic changes
2445
+
2446
+ The schematic visits every file of the workspace except `node_modules`, build output and the files your `.gitignore` excludes.
2447
+
2448
+ ### Dependencies
2449
+
2450
+ In every `package.json` of the workspace, including `overrides` and `resolutions`, each package is replaced by its counterpart:
2451
+
2452
+ - `primeng` becomes `@exhaustive-ui/core`
2453
+ - `@primeuix/themes`, `@primeuix/styled`, `@primeuix/styles`, `@primeuix/utils` and `@primeuix/motion` become `@exhaustive-ui/themes`, `@exhaustive-ui/styled`, `@exhaustive-ui/styles`, `@exhaustive-ui/utils` and `@exhaustive-ui/motion`
2454
+ - `tailwindcss-primeui` becomes `@exhaustive-ui/tailwindcss`
2455
+ - `primelocale` becomes `@exhaustive-ui/locale`
2456
+ - `primeicons` becomes `@openng/icons`
2457
+
2458
+ ### TypeScript
2459
+
2460
+ Imports, dynamic imports and `require()` calls are rewritten, subpaths included (`primeng/button` becomes `@exhaustive-ui/core/button`, `@primeuix/themes/aura` becomes
2461
+ `@exhaustive-ui/themes/aura`), and so is the Tailwind CSS configuration file. The configuration API is renamed where it is imported: `providePrimeNG` becomes `provideExhaustive`, the `PrimeNG` service becomes
2462
+ `Exhaustive`, `PrimeNGConfigType` becomes `ExhaustiveConfigType`, and the `PrimeIcons` constants become `OpenngIcons`.
2463
+
2464
+ ```typescript
2465
+ // Before
2466
+ import { ApplicationConfig } from '@angular/core';
2467
+ import { providePrimeNG } from 'primeng/config';
2468
+ import Aura from '@primeuix/themes/aura';
2469
+
2470
+ export const appConfig: ApplicationConfig = {
2471
+ providers: [providePrimeNG({ theme: { preset: Aura } })]
2472
+ };
2473
+
2474
+ // After
2475
+ import { ApplicationConfig } from '@angular/core';
2476
+ import { provideExhaustive } from '@exhaustive-ui/core/config';
2477
+ import Aura from '@exhaustive-ui/themes/aura';
2478
+
2479
+ export const appConfig: ApplicationConfig = {
2480
+ providers: [provideExhaustive({ theme: { preset: Aura } })]
2481
+ };
2482
+ ```
2483
+
2484
+ ### Stylesheets and angular.json
2485
+
2486
+ `@import`, `@use`, `@plugin` and `url()` references in stylesheets, and the `styles` and `scripts` entries of `angular.json` and `project.json`, follow the new package names.
2487
+ `primeicons/primeicons.css` becomes `@openng/icons/openng-icons.css`; the `pi pi-*` classes in templates do not change.
2488
+
2489
+ ### CSS cascade layer
2490
+
2491
+ When the theme sets `cssLayer`, the `primeng` layer becomes `exhaustive` in its `name` and `order`, `primeng-overwrites` becomes `exhaustive-overwrites`, and the matching
2492
+ `@layer` declarations in your stylesheets are renamed too, so your overrides keep their place in the layer order. With `cssLayer: true`, the configuration does not change, and only the stylesheets are renamed.
2493
+
2494
+ ### The report
2495
+
2496
+ The schematic ends with the places that still mention `primeng`, `primeicons`, `@primeuix`, `tailwindcss-primeui` or `primelocale`, with the file and line: templates, Markdown, JSON or code it does not
2497
+ rewrite. Lockfiles are left out of the report, since the install regenerates them.
2498
+
2499
+ ## Manual checks
2500
+
2501
+ Besides the places listed in the report, check these by hand:
2502
+
2503
+ - **The icon font name.** A stylesheet that names the font directly, as in `font-family: 'primeicons'`, now needs `'openng-icons'`. The schematic does not touch declaration values.
2504
+ - **Local variables named after PrimeNG**, such as `primeng = inject(PrimeNG)`: the type is renamed, the variable name is yours to keep or change.
2505
+ - **Module paths passed to other functions**, such as `jest.mock('primeng/button')` or `vi.mock()`: only imports, dynamic imports and `require()` are rewritten. These appear in the report.
2506
+ - **Build and deployment files** outside the TypeScript sources and stylesheets: Dockerfiles, CI scripts, CDN links to PrimeNG or PrimeIcons.
2507
+ - **PrimeTek products** such as templates or the theme designer are not part of ExhaustiveUI. A preset built with them is a plain `definePreset()` object and keeps working once its imports point to `@exhaustive-ui/themes`.
2508
+
2509
+ ## What changes in v22
2510
+
2511
+ After the switch, the application runs on ExhaustiveUI v22, which differs from PrimeNG v21 in ways the compiler and your tests will show. The [migration guide to v22](https://exhaustive-ui.com/migration/v22)
2512
+ details each of them:
2513
+
2514
+ - Inputs, two-way properties, outputs and queries are signals: code holding a component instance reads inputs with a call and writes two-way properties with `.set()`.
2515
+ - Components use OnPush change detection, except Table, TreeTable and DynamicDialog: give them new arrays and objects, or signals, rather than mutating bound data.
2516
+ - Deprecated and inactive inputs are removed or renamed, `styleClass` becomes `class` on most components; the v22 migrations rewrite these bindings and report the rest.
2517
+ - Hundreds of bugs inherited from PrimeNG v21 are fixed, each with a regression test; a few of them change a visible behavior.
2518
+
2519
+ ## Checklist
2520
+
2521
+ - Angular 22 installed, and no `primeng`, `@primeuix/*`, `primeicons`, `tailwindcss-primeui` or `primelocale` left in any `package.json`.
2522
+ - The report of `migrate-from-primeng` handled, then the report of the v22 migrations.
2523
+ - Icons render: the stylesheet is `@openng/icons/openng-icons.css` and nothing names the `primeicons` font.
2524
+ - With a CSS layer configured, your overrides still apply: the `@layer` names match the theme's `cssLayer` order.
2525
+ - The application compiles and its tests pass, after the code changes of the migration guide to v22.
2526
+ - PrimeFlex, if used, migrated with `migrate-from-primeflex`.
2527
+
2528
+ ---
2529
+
2530
+ # Migrating from Optimus UI
2531
+
2532
+ Moving an Optimus UI v2 application to ExhaustiveUI: package and configuration API renames, the CSS layer name, then the v22 migrations.
2533
+
2534
+ ## Overview
2535
+
2536
+ ExhaustiveUI is a fork of Optimus UI, itself the MIT continuation of PrimeNG v21. An Optimus UI v2 application already runs on Angular 22 and uses the same components, selectors, CSS classes, design tokens and
2537
+ `@openng/icons` icons. Moving it across takes two steps:
2538
+
2539
+ 1. **The rename**: the `@openng/optimus-ui*` packages become `@exhaustive-ui/*`, and the four names of the configuration API change. The `migrate-from-optimus` schematic does it.
2540
+ 2. **The v22 changes**: the Signals API everywhere, OnPush and the API cleanup of ExhaustiveUI v22. The `ng update` migrations do most of it, and the [migration guide to v22](https://exhaustive-ui.com/migration/v22) covers the rest.
2541
+
2542
+ ## Before you start
2543
+
2544
+ - **Optimus UI v2 on Angular 22.** An application still on Optimus UI v1 updates to v2 first, following Optimus UI's documentation.
2545
+ - **A clean git working tree**, so the rename and the migrations can be reviewed on their own, and a build and test run that passes before you start.
2546
+
2547
+ ## Migration steps
2548
+
2549
+ 1. Install ExhaustiveUI and run the `migrate-from-optimus` schematic. It rewrites the workspace, then installs the new dependencies.
2550
+ 2. Run the v22 migrations. The workspace did not go through `ng update`, so they are run explicitly, from the version before v22.
2551
+ 3. Read both reports, fix the compiler errors, then build and run your tests.
2552
+
2553
+ ```bash
2554
+ npm install @exhaustive-ui/core@22
2555
+ ng generate @exhaustive-ui/core:migrate-from-optimus
2556
+ ng update @exhaustive-ui/core --migrate-only --from=3.0.0
2557
+ ```
2558
+
2559
+ The schematic checks that `@openng/optimus-ui` v2 is installed. It takes two options: `--skip-install` leaves the install to you, and `--force` skips the version check. Like `ng update`, run it on a clean
2560
+ working tree so its changes can be reviewed with `git diff`.
2561
+
2562
+ ## What the schematic changes
2563
+
2564
+ The schematic visits every file of the workspace except `node_modules`, build output and the files your `.gitignore` excludes.
2565
+
2566
+ ### Dependencies
2567
+
2568
+ In every `package.json` of the workspace, each package is replaced by its counterpart, which has the same content and the same subpaths:
2569
+
2570
+ - `@openng/optimus-ui` becomes `@exhaustive-ui/core`
2571
+ - `@openng/optimus-ui-themes`, `-tailwindcss`, `-locale`, `-styled`, `-styles`, `-utils` and `-motion` become `@exhaustive-ui/themes`, `tailwindcss`, `locale`, `styled`, `styles`, `utils` and `motion`
2572
+ - `@openng/icons` stays: ExhaustiveUI uses the same icon set.
2573
+
2574
+ ### TypeScript
2575
+
2576
+ Imports, dynamic imports and `require()` calls are rewritten, subpaths included (`@openng/optimus-ui/button` becomes `@exhaustive-ui/core/button`), and so is the Tailwind CSS configuration file. The
2577
+ configuration API is renamed where it is imported from Optimus UI, along with every use in the file: `provideOptimus` becomes `provideExhaustive`, the `Optimus` service becomes `Exhaustive`,
2578
+ `OptimusConfigType` becomes `ExhaustiveConfigType` and `OPTIMUS_CONFIG` becomes `EXHAUSTIVE_CONFIG`. A class of your own that happens to be named `Optimus` is left alone.
2579
+
2580
+ ```typescript
2581
+ // Before
2582
+ import { ApplicationConfig } from '@angular/core';
2583
+ import { provideOptimus } from '@openng/optimus-ui/config';
2584
+ import Aura from '@openng/optimus-ui-themes/aura';
2585
+
2586
+ export const appConfig: ApplicationConfig = {
2587
+ providers: [provideOptimus({ theme: { preset: Aura } })]
2588
+ };
2589
+
2590
+ // After
2591
+ import { ApplicationConfig } from '@angular/core';
2592
+ import { provideExhaustive } from '@exhaustive-ui/core/config';
2593
+ import Aura from '@exhaustive-ui/themes/aura';
2594
+
2595
+ export const appConfig: ApplicationConfig = {
2596
+ providers: [provideExhaustive({ theme: { preset: Aura } })]
2597
+ };
2598
+ ```
2599
+
2600
+ ### Stylesheets and angular.json
1420
2601
 
1421
- ## Major-versions
2602
+ `@import`, `@use`, `@plugin` and `url()` references in stylesheets, and the `styles` and `scripts` entries of `angular.json` and `project.json`, follow the new package names.
1422
2603
 
1423
- Each ExhaustiveUI major targets a single Angular major. To move to a new major, update Angular first — the Angular update guide covers that step — then update ExhaustiveUI to the matching major by passing the target version. For example, once Angular v23 and ExhaustiveUI v23 are out, from v22: Review the release notes of the target version for breaking changes before you start.
2604
+ ### The report
1424
2605
 
1425
- ## Ng-update
2606
+ The schematic ends with the places that still mention `optimus-ui`, `Optimus`, `provideOptimus`, `OptimusConfigType` or `OPTIMUS_CONFIG`, with the file and line: templates, Markdown, comments, or module paths
2607
+ passed to other functions, such as `jest.mock()`. Lockfiles are left out, since the install regenerates them.
2608
+
2609
+ ## CSS layer
2610
+
2611
+ Optimus UI puts its styles in a CSS cascade layer named `optimus` when the theme enables `cssLayer`; ExhaustiveUI names it `exhaustive`. The schematic renames the `optimus` token in the `cssLayer`
2612
+ `name` and `order` of your configuration, then the matching `@layer` declarations and `@import ... layer()` clauses in your stylesheets, so your overrides keep their place in the layer order. With
2613
+ `cssLayer: true`, the configuration does not change, and only the stylesheets are renamed.
2614
+
2615
+ A layer of your own, with another name, is left as it is. The CSS classes (`p-button`...), the design tokens (`--p-primary-color`...) and the icon classes (`pi pi-check`...) do not change.
2616
+
2617
+ ## v22 migrations
2618
+
2619
+ After `migrate-from-optimus`, run the v22 migrations. The workspace did not go through `ng update`, so they are run explicitly, from the version before v22:
2620
+
2621
+ ```bash
2622
+ ng update @exhaustive-ui/core --migrate-only --from=3.0.0
2623
+ ```
1426
2624
 
1427
- Run ng update without arguments at any time to list the updates available in your workspace, ExhaustiveUI included. To update within the current major, pass the main package. The Angular CLI resolves the rest: @exhaustive-ui/core declares all its companion packages as a group, so every installed @exhaustive-ui/* package — themes, locale, Tailwind CSS plugin and the internal runtime packages — is updated together and the suite cannot end up on mixed versions. Like any ng update run, the command expects a clean git working tree so its changes can be reviewed or reverted in isolation — commit or stash your work first.
2625
+ They rewrite the templates and code for the inputs, outputs and templates removed or renamed in v22, and for the configuration options that became signals or changed name, such as `inputStyle`, now `inputVariant`. They
2626
+ report what they cannot rewrite. The [migration guide to v22](https://exhaustive-ui.com/migration/v22) then covers the code changes: signal inputs, `model()` and signal queries in every component, OnPush change
2627
+ detection, and the behavior and type changes.
2628
+
2629
+ ## Checklist
2630
+
2631
+ - No `@openng/optimus-ui*` package left in any `package.json`, and the report of `migrate-from-optimus` handled.
2632
+ - `provideExhaustive`, `Exhaustive`, `ExhaustiveConfigType` and `EXHAUSTIVE_CONFIG` in place of the Optimus names.
2633
+ - With a CSS layer configured, your overrides still apply.
2634
+ - The v22 migrations run and their report handled.
2635
+ - The application compiles and its tests pass, after the code changes of the migration guide to v22.
2636
+
2637
+ ---
2638
+
2639
+ # Migrating to v22
2640
+
2641
+ Moving an application to ExhaustiveUI v22: update steps from an ExhaustiveUI prerelease, PrimeNG v21 or Optimus UI, the automated migrations and their report, the Signals API, OnPush, removed API, behavior and type changes.
1428
2642
 
1429
2643
  ## Overview
1430
2644
 
1431
- All @exhaustive-ui/core packages — the components, themes, locale definitions, Tailwind CSS plugin and their internal dependencies — are versioned and released together, so an update always moves the whole suite to a single new version. ExhaustiveUI supports ng update , the Angular CLI's own update mechanism, which bumps every installed ExhaustiveUI package in one step and runs any automated code migrations shipped with the new version. Major versions follow Angular's: when a new Angular major ships, a matching ExhaustiveUI major is released for it. Minor and patch releases stay within the same Angular major and are drop-in updates. This page is about updating a project that already uses ExhaustiveUI. To move an existing PrimeNG workspace across, see the migration guide instead.
2645
+ ExhaustiveUI v22 requires Angular 22 and moves every component and directive to the Angular Signals API. Templates bind as before: `[name]`, `[(name)]` and `(name)` keep working. Most of the work is done by
2646
+ `ng update`. What is left is code that reaches into a component instance, data mutated in place under OnPush components, and the few places the migrations report.
2647
+
2648
+ This guide covers three starting points:
2649
+
2650
+ - **A v22 alpha or release candidate** of ExhaustiveUI: update to 22.0.0 with `ng update`, which runs the migrations. They leave code that is already migrated as it is, so running them again is safe.
2651
+ - **PrimeNG v21**: switch to ExhaustiveUI with the `migrate-from-primeng` schematic, then run the v22 migrations explicitly.
2652
+ - **Optimus UI v2**, which shares the PrimeNG v21 API: swap the packages and imports, then run the v22 migrations explicitly.
2653
+
2654
+ Updating later within v22, or to a future major, is covered by the [update guide](https://exhaustive-ui.com/migration/update). Every breaking change below is also listed in the
2655
+ [changelog](https://github.com/e-xiste/exhaustive-ui/blob/main/CHANGELOG.md).
2656
+
2657
+ ## Before you start
2658
+
2659
+ - **Angular 22.** The peer dependencies are `^22.0.0`. Update Angular first with the [Angular update guide](https://angular.dev/update-guide), and use the Node.js and TypeScript versions it requires.
2660
+ - **A clean git working tree.** Commit or stash your work, so the changes made by the migrations can be reviewed, and reverted, on their own.
2661
+ - **A build and test run that passes** before you start, so anything that breaks afterwards comes from the update.
2662
+ - **PrimeFlex**, if the project uses it: it is not part of the update. The `migrate-from-primeflex` schematic translates its classes to Tailwind CSS, as a separate step.
2663
+
2664
+ ## Update steps
2665
+
2666
+ ### From an ExhaustiveUI alpha or release candidate
2667
+
2668
+ Update Angular, then ExhaustiveUI. Every installed `@exhaustive-ui/*` package moves to 22.0.0 together, and the migrations run.
2669
+
2670
+ ```bash
2671
+ ng update @angular/core@22 @angular/cli@22
2672
+ ng update @exhaustive-ui/core@22
2673
+ ```
2674
+
2675
+ ### From PrimeNG v21
2676
+
2677
+ Update Angular to 22, install ExhaustiveUI and run the `migrate-from-primeng` schematic. It swaps the `primeng`, `@primeuix/*` and PrimeIcons dependencies, rewrites the imports (`primeng/button` becomes
2678
+ `@exhaustive-ui/core/button`) and renames the configuration API (`providePrimeNG` becomes `provideExhaustive`). The workspace did not go through `ng update`, so run the v22 migrations explicitly afterwards.
2679
+
2680
+ ```bash
2681
+ ng update @angular/core@22 @angular/cli@22 --force
2682
+ npm install @exhaustive-ui/core@22
2683
+ ng generate @exhaustive-ui/core:migrate-from-primeng
2684
+ ng update @exhaustive-ui/core --migrate-only --from=3.0.0
2685
+ ```
2686
+
2687
+ Projects on PrimeNG v20 or older upgrade to PrimeNG v21 first; the schematic checks the version and refuses otherwise. The [PrimeNG migration guide](https://exhaustive-ui.com/migration/primeng) details each step,
2688
+ including the `--force` the Angular update needs while `primeng` is installed.
2689
+
2690
+ ### From Optimus UI v2
2691
+
2692
+ Optimus UI v2 has the PrimeNG v21 API under other package names. The `migrate-from-optimus` schematic swaps its packages for their `@exhaustive-ui/*` counterparts and renames the imports, the configuration API and the
2693
+ CSS layer; then run the v22 migrations explicitly. The [Optimus UI migration guide](https://exhaustive-ui.com/migration/optimus) details each step.
2694
+
2695
+ ```bash
2696
+ npm install @exhaustive-ui/core@22
2697
+ ng generate @exhaustive-ui/core:migrate-from-optimus
2698
+ ng update @exhaustive-ui/core --migrate-only --from=3.0.0
2699
+ ```
2700
+
2701
+ ### Then
2702
+
2703
+ 1. Read the report the migrations printed, see `Reviewing the report` below.
2704
+ 2. Fix the TypeScript errors: most come from the Signals API and the removed TypeScript API.
2705
+ 3. Check the screens that mutate data bound to a component, which no longer refresh under OnPush.
2706
+ 4. Read the behavior changes, then build and run your tests.
2707
+
2708
+ ## Automated migrations
2709
+
2710
+ `ng update` applies nine migrations to the templates (inline and external) and the TypeScript code of every project in the workspace. Each one only touches the ExhaustiveUI elements and APIs it knows, and reports what it cannot
2711
+ rewrite safely.
2712
+
2713
+ - **styleclass-to-class**: `styleClass`/`[styleClass]` becomes `class`/`[class]` on the ~60 components whose deprecated `styleClass` input was removed, such as Tag, Card, Select, Table, DatePicker, Panel, AvatarGroup and InputGroupAddon.
2714
+ - **renamed-inputs**: Drawer `showCloseIcon` becomes `closable` and `ariaCloseLabel` becomes `closeAriaLabel`; Paginator `dropdownAppendTo` becomes `appendTo`; Password `maxLength` becomes `maxlength`; AutoComplete `minLength` becomes `minQueryLength`; TreeSelect `containerStyleClass`/`containerStyle` become `class`/`style`; TreeTable `virtualRowHeight` becomes `virtualScrollItemSize`; Listbox and MultiSelect `filterPlaceHolder` becomes `filterPlaceholder`; ImageCompare `ariaLabelledby` becomes `ariaLabelledBy`; Dialog `[content]`, which set the header template, becomes `[headerTemplate]`; the `pt*` pass-through aliases of pButton, pButtonLabel, pButtonIcon, pBadge, pInputText and pTooltip become `pButtonPT`, `pButtonLabelPT`, `pButtonIconPT`, `pBadgePT`, `pInputTextPT` and `pTooltipPT`; pBadge `size` on a plain element becomes `badgeSize`.
2715
+ - **renamed-outputs**: OrderList `onFilterEvent` becomes `onFilter`; Table `selectAllChange` becomes `onSelectAllChange`; MultiSelect `onPanelShow`/`onPanelHide` become `onShow`/`onHide`. The payloads are unchanged, so handlers reading `$event` keep working.
2716
+ - **renamed-templates**: the MultiSelect `removetokenicon` template becomes `chipicon`, with the same context.
2717
+ - **remove-dead-inputs**: removes the bindings of about eighty inputs that had already stopped doing anything, such as the `*TransitionOptions` inputs (replaced by `motionOptions`), `autoZIndex`/`baseZIndex` on sub menus, Table `frozenColumns`/`frozenWidth`, the ConfirmDialog aria labels and the `trackBy` inputs of DataView, OrderList and PickList.
2718
+ - **remove-dead-outputs**: removes Overlay `onAnimationStart`/`onAnimationDone` and MenubarSub `menuFocus`/`menuBlur`/`menuKeydown`.
2719
+ - **config-overlay-options-signal**: `Exhaustive.overlayOptions` is a signal. Assignments become `.set()` and reads become calls.
2720
+ - **config-input-style-to-variant**: the global `inputStyle` option becomes `inputVariant` (same values), in `provideExhaustive()`/`setConfig()` objects and on the `Exhaustive` service.
2721
+ - **removed-exports**: `Password_VALUE_ACCESSOR` becomes `PASSWORD_VALUE_ACCESSOR`; the removed `InplaceDisplay`/`InplaceContent` wrappers are dropped from imports and their elements become `<span>`.
2722
+
2723
+ ## Reviewing the report
2724
+
2725
+ Each migration prints the files it changed, then the places it left for you, with the file and line. These are the cases it reports and what to do with them.
2726
+
2727
+ - **Programmatic access to a removed or renamed name**, such as `drawer.showCloseIcon = true` or `table.selectAllChange.subscribe(...)`: use the new name, and the Signals API described below.
2728
+ - **A tag that binds both the old and the new name**: keep the new one and delete the old one, after checking which value you meant.
2729
+ - **A Table `[(selectAll)]` two-way binding**, which relied on the renamed `selectAllChange`: bind `[selectAll]="selectAll"` and `(onSelectAllChange)="selectAll = $event.checked"`.
2730
+ - **A MultiSelect that already projects a `chipicon` template** next to `removetokenicon`: keep one of them.
2731
+ - **A configuration object that sets both `inputStyle` and `inputVariant` , or a receiver the migration cannot prove to be the `Exhaustive` service: set `inputVariant` only.
2732
+ - Imports of rendering internals that are no longer exported**: the `SelectItem` option component of Select (the `SelectItem` interface of `@exhaustive-ui/core/api` is unchanged), Menu's `SafeHtmlPipe`, `MapperPipe`, `RadioControlRegistry` and `MenubarService`. Remove the import; the components no longer need them from you.
2733
+
2734
+ Coding agents can check the result with the `validate_usage` tool of the `@exhaustive-ui/mcp` server, which names the replacement of every input removed or renamed in v22, and follow its `update_to_v22` prompt.
2735
+
2736
+ ## Code using a component instance
2737
+
2738
+ Every input is an `input()`, every two-way property a `model()`, every output an `output()` and every query a signal query. No `@Input`, `@Output`, `@ViewChild` or
2739
+ `@ContentChild` decorator is left. Templates are not affected, and the migrations do not rewrite this kind of code: the compiler points at each place.
2740
+
2741
+ - Read an input by calling it: `table.first()`, not `table.first`.
2742
+ - Inputs can no longer be assigned from code. Bind them in the template to a field or a signal of your component, and change that instead.
2743
+ - Two-way properties are `model()` signals: write them with `.set()`, as in `drawer.visible.set(true)`. The value and change-event pairs became models, for example `first`, `rows` and `selection` on Table and TreeTable, and `visible` on Dialog, Drawer and Galleria. `[(x)]` bindings keep working.
2744
+ - Outputs are `OutputEmitterRef`s: `.subscribe()` still works, `.pipe()` and the other `EventEmitter` members do not. Use `outputToObservable()` when you need an observable.
2745
+ - Public child references of a component are signal queries too, and are read with a call.
2746
+ - The global configuration is a set of signals on the `Exhaustive` service: `config.ripple.set(true)`, `config.inputVariant()`.
2747
+
2748
+ ```typescript
2749
+ // Before
2750
+ @ViewChild(Table) table!: Table;
2751
+ @ViewChild(Drawer) drawer!: Drawer;
2752
+
2753
+ reset() {
2754
+ const first = this.table.first;
2755
+ this.table.selection = [];
2756
+ this.drawer.visible = false;
2757
+ this.config.ripple = true;
2758
+ }
2759
+
2760
+ // After
2761
+ table = viewChild.required(Table);
2762
+ drawer = viewChild.required(Drawer);
1432
2763
 
1433
- ## Release-notes
2764
+ reset() {
2765
+ const first = this.table().first();
2766
+ this.table().selection.set([]);
2767
+ this.drawer().visible.set(false);
2768
+ this.config.ripple.set(true);
2769
+ }
2770
+ ```
2771
+
2772
+ ## OnPush change detection
2773
+
2774
+ Every component uses `OnPush` change detection, except Table, TreeTable and DynamicDialog, which stay Eager on purpose because they render objects that applications commonly mutate in place. An OnPush component refreshes when one
2775
+ of its inputs gets a new value, when it handles an event, or when a signal it reads changes. It does not see a change made inside an array or an object it already holds.
2776
+
2777
+ The symptom is a component that does not update: options added with `push()` that do not appear in a Select, a Tree node renamed in place, a chart that keeps its old data. Give the component a new array or object, or keep the
2778
+ data in a signal.
2779
+
2780
+ ```typescript
2781
+ // Before: the Select does not show the new option under OnPush
2782
+ this.cities.push({ name: 'Paris', code: 'PRS' });
2783
+
2784
+ // After: a new array
2785
+ this.cities = [...this.cities, { name: 'Paris', code: 'PRS' }];
2786
+
2787
+ // Or a signal, bound with [options]="cities()"
2788
+ cities = signal<City[]>([]);
2789
+ this.cities.update((cities) => [...cities, { name: 'Paris', code: 'PRS' }]);
2790
+ ```
2791
+
2792
+ Templates use the built-in `@if`, `@for` and `@switch` control flow, and option lists, menus, Paginator and DatePicker reuse their rows when the data is replaced instead of recreating them. Replacing the
2793
+ array is therefore cheap, and no NG0955 or NG0956 warning comes from the library.
2794
+
2795
+ ## Removed TypeScript API
2796
+
2797
+ These removals have no migration: they only appear in TypeScript code, and the compiler points at each use.
2798
+
2799
+ - `OverlayOptions.showTransitionOptions`/`hideTransitionOptions` and `DynamicDialogConfig.rtl`/`transitionOptions`: nothing read them. Use `motionOptions`.
2800
+ - `@exhaustive-ui/utils`: `classNames` becomes `cn`, `createStyleAsString` becomes `createStyleMarkup`, `createStyleTag` becomes `createStyleElement`, `mergeKeys` becomes `deepMerge`.
2801
+ - `@exhaustive-ui/styled`: `getDirective` on the theme service becomes `getComponent`.
2802
+ - Sub components that render the inside of a component (`ContextMenuSub`, `TieredMenuSub`, `MenuItemContent`, `MultiSelectItem`, `ToastItem`, `TableBody`, `TTBody`, `UITreeNode`, the Galleria parts...), `PARENT_INSTANCE` and the pre-signals helpers of `@exhaustive-ui/core/utils` are still exported in v22 but tagged `@internal`. They are not public API and can change in a minor release.
2803
+
2804
+ ## Behavior changes
1434
2805
 
1435
- Every version is published with its notes on the GitHub releases page , covering new features, fixes and any breaking changes or manual steps a release requires. Check the notes for the target version before a major update.
2806
+ These changes compile without error but can change what users see, or what a test asserts. Most come from fixes of bugs inherited from PrimeNG and Optimus UI. The issue numbers in the changelog are Optimus UI's.
1436
2807
 
1437
- ## V22
2808
+ ### Forms
1438
2809
 
1439
- ExhaustiveUI v22 is the first major of the fork. It requires Angular v22 and moves the whole library to the Angular Signals API. Templates keep working as before: inputs are still bound with [name] , two-way bindings with [(name)] , and outputs with (name) . What changes is code that reaches into a component instance. Inputs are signal inputs: read them as component.name() rather than component.name , and set them through a template binding rather than by assignment. Two-way properties such as visible , value or selection are model() signals; call .set() on them from code. Template and child queries are signal queries ( contentChild() , viewChild() , ...), read with a call as well. Components use OnPush change detection, except Table, TreeTable and DynamicDialog. State shared with them should be passed through inputs or signals rather than mutated in place. Templates use the built-in @if / @for control flow, and option lists, menus and paginators track rows by position, so replacing the model no longer recreates every row. Run the update with ng update ; it applies the automated migrations shipped with v22 to your templates and code: styleclass-to-class : styleClass becomes the native class attribute on the components that dropped the input. renamed-inputs : deprecated aliases are renamed to their replacement, e.g. showCloseIcon to closable on Drawer, minLength to minQueryLength on AutoComplete, virtualRowHeight to virtualScrollItemSize on TreeTable, filterPlaceHolder to filterPlaceholder on Listbox and MultiSelect. renamed-outputs : outputs are renamed to the name the other components use, with the same event payload: onFilterEvent to onFilter on OrderList, selectAllChange to onSelectAllChange on Table, onPanelShow / onPanelHide to onShow / onHide on MultiSelect. renamed-templates : the removetokenicon template of MultiSelect becomes chipicon . remove-dead-inputs and remove-dead-outputs : bindings of inputs and outputs that already had no effect are removed. config-overlay-options-signal : overlayOptions on the global configuration is a signal; assignments become .set() and reads become calls. removed-exports : Password_VALUE_ACCESSOR becomes PASSWORD_VALUE_ACCESSOR , and the removed p-inplacedisplay / p-inplacecontent wrappers become a span . config-input-style-to-variant : the global inputStyle option, deprecated since v20, becomes inputVariant in provideExhaustive() and on the configuration service. Each migration prints the files it changed and the places it left for you to review, with file and line numbers. A workspace that has just switched to ExhaustiveUI, from PrimeNG with the migrate-from-primeng schematic or from Optimus UI, did not go through ng update . Run the migrations explicitly:
2810
+ - InputText: when `[invalid]` is bound, it alone decides the invalid style; the automatic `ng-invalid ng-dirty` border no longer applies on top of it.
2811
+ - InputNumber: a keystroke that would make the formatted value longer than `maxlength` is rejected instead of truncating the text. The native `min`/`max` attributes are gone; the bounds stay in `aria-valuemin`/`aria-valuemax`.
2812
+ - Select: a Select inside a disabled `<fieldset>` is disabled, except inside the fieldset's first `<legend>`, as for native controls.
2813
+ - Select, MultiSelect and CascadeSelect use the SVG spinner of Button as their default loading icon, instead of the `pi-spin` icon class.
2814
+ - PickList: moving items sets `source` and `target` to new arrays and emits `sourceChange`/`targetChange`, so `[(source)]`/`[(target)]` bindings follow.
2815
+ - TreeTable: the selection change can fire once per intermediate step while a checkbox propagates.
2816
+ - DatePicker: the `data-date` attribute of day cells uses a 1-based month.
2817
+ - AutoFocus: the native `autofocus` attribute is only rendered when autofocus is on; Button and the other components no longer carry it by default.
2818
+
2819
+ ### Overlays and menus
2820
+
2821
+ - Overlays are placed against the viewport without its scrollbars, so an overlay at the right edge no longer goes under the vertical scrollbar.
2822
+ - Tooltip honours the global `overlayAppendTo` option.
2823
+ - TieredMenu: with `autoDisplay`, submenus open on hover from the start, without a first click. A popup TieredMenu gives the focus back to its trigger when an item is picked.
2824
+ - ContextMenu: showing a context menu closes any other one that is open.
2825
+ - ConfirmPopup: an `accepticon`/`rejecticon` template replaces the `acceptIcon`/`rejectIcon` class instead of rendering next to it, as in ConfirmDialog.
2826
+
2827
+ ### Accessibility markup
2828
+
2829
+ - Stepper: the `tablist` role is on `p-step-list`. Splitter: the `separator` role is on the focusable gutter handle.
2830
+ - FocusTrap sentinels are no longer `aria-hidden`. ConfirmDialog no longer puts a `role` on the `p-dialog` host.
2831
+ - Table announces keyboard column and row moves through the new `aria.columnMoved` and `aria.rowMoved` translation keys. A custom `aria` translation without them falls back to English.
2832
+
2833
+ ### Theming and display
2834
+
2835
+ - A token overridden under `colorScheme.light` wins over the preset's top-level token, as it already did in dark mode. A top-level override passed to `definePreset`, `updatePreset` or `usePreset` still wins.
2836
+ - MeterGroup: meter widths use the exact percentage; labels keep the rounded value.
2837
+ - ToggleSwitch has no `size` input any more: it had no effect.
2838
+
2839
+ ## Type changes
2840
+
2841
+ Some types now describe what the components actually emit or accept. Code that relied on the old types may need a cast or a narrower check.
2842
+
2843
+ - Table `onFilter`: `filters` is typed `FilterMetadata | FilterMetadata[]`.
2844
+ - TreeTable `TreeTableLazyLoadEvent`: `first` is a `number` and `last` an optional `number`, as in `TableLazyLoadEvent`.
2845
+ - CascadeSelect: `options` is typed as an array, and the value accepts an object.
2846
+ - Dialog and ConfirmDialog: `pt.root` is typed as the options of the root element.
2847
+ - Chart `onDataSelect` emits the new exported `ChartDataSelectEvent` type.
2848
+ - `Confirmation` accepts `draggable`, and DatePicker `hourFormat` also accepts a number.
2849
+
2850
+ ## Checklist
2851
+
2852
+ - Angular 22 installed, and `ng update` (or `--migrate-only --from=3.0.0`) run on a clean working tree.
2853
+ - Every place listed in the migration report handled.
2854
+ - The project compiles: inputs are read with a call, two-way properties written with `.set()`, removed TypeScript API replaced.
2855
+ - No `styleClass`, removed input or `pt*` alias left in templates: `validate_usage` of the MCP server can check this.
2856
+ - Screens that change data bound to a component show the change: new arrays and objects, or signals, rather than in-place mutation.
2857
+ - Behavior changes reviewed against your tests and screenshots.
2858
+ - Signal Forms, if you adopt them: a required field shows as invalid before any interaction, because `[invalid]` cannot be bound next to `[formField]`. A fix is planned in a v22 minor release.
1440
2859
 
1441
2860
  ---
1442
2861
 
@@ -1444,21 +2863,87 @@ ExhaustiveUI v22 is the first major of the fork. It requires Angular v22 and mov
1444
2863
 
1445
2864
  How to contribute to ExhaustiveUI.
1446
2865
 
1447
- ## Benefits
2866
+ ## Introduction
1448
2867
 
1449
- Contributing to ExhaustiveUI comes with several benefits. Being part of an open-source project will enhance your career and open up exciting opportunities. You'll gain significant visibility in the developer community while improving yourself as a professional.
2868
+ ExhaustiveUI is a community-maintained Angular UI library, stewarded by e-xiste and dedicated to providing high-quality, versatile and accessible UI components that help developers build better applications faster.
1450
2869
 
1451
- ## Helpneeded
2870
+ ### Development Setup
1452
2871
 
1453
- ExhaustiveUI is a community-driven project stewarded by e-xiste, and we appreciate any help you can provide. Here are some areas where you can contribute: Issue Triage Help us manage issues by; Reproducing reported bugs Clarifying issue descriptions Tagging issues with appropriate labels Sending Pull Requests We encourage you to send pull requests, especially for issues tagged with the help-needed label. Community Support Assist other users by participating in the issue tracker and GitHub discussions . Your expertise can help others solve problems and improve their experience with ExhaustiveUI.
2872
+ To begin with, clone the ExhaustiveUI repository from GitHub:
1454
2873
 
1455
- ## Introduction
2874
+ ```typescript
2875
+ git clone https://github.com/e-xiste/exhaustive-ui.git
2876
+ cd exhaustive-ui
2877
+ ```
2878
+
2879
+ Then run the documentation app in your local environment at `http://localhost:4200/`.
2880
+
2881
+ ```typescript
2882
+ pnpm install
2883
+ pnpm run dev
2884
+ ```
2885
+
2886
+ ### Project Structure
2887
+
2888
+ ExhaustiveUI's project structure is organized as follows:
2889
+
2890
+ ```typescript
2891
+ - apps
2892
+ - docs // this documentation website
2893
+ - tailwind-playgrounds // Tailwind integration sandboxes
2894
+ - packages
2895
+ - core // components, directives and services
2896
+ - themes // built-in theme presets
2897
+ - styled // styled-mode theming engine
2898
+ - styles // base styles
2899
+ - tailwindcss // Tailwind CSS plugin
2900
+ - locale // i18n locales
2901
+ - motion // animation utilities
2902
+ - utils // shared helpers
2903
+ ```
2904
+
2905
+ ## Help Needed
2906
+
2907
+ ExhaustiveUI is a community-driven project stewarded by e-xiste, and we appreciate any help you can provide. Here are some areas where you can contribute:
2908
+
2909
+ ### Issue Triage
1456
2910
 
1457
- ExhaustiveUI is a community-maintained Angular UI library, stewarded by e-xiste and dedicated to providing high-quality, versatile and accessible UI components that help developers build better applications faster. Development Setup To begin with, clone the ExhaustiveUI repository from GitHub: Then run the documentation app in your local environment at http://localhost:4200/ . Project Structure ExhaustiveUI's project structure is organized as follows:
2911
+ Help us manage issues by;
2912
+
2913
+ - Reproducing reported bugs
2914
+ - Clarifying issue descriptions
2915
+ - Tagging issues with appropriate labels
2916
+
2917
+ ### Sending Pull Requests
2918
+
2919
+ We encourage you to send pull requests, especially for issues tagged with the `help-needed` label.
2920
+
2921
+ ### Community Support
2922
+
2923
+ Assist other users by participating in the issue tracker and [GitHub discussions](https://github.com/e-xiste/exhaustive-ui/discussions). Your expertise can help others solve
2924
+ problems and improve their experience with ExhaustiveUI.
2925
+
2926
+ ## AI Contributions
2927
+
2928
+ Contributions written with AI coding agents are welcome, on the same terms as any other: the pull request is yours. You understand the change and can answer questions about it in review, it is scoped to one problem, and it comes with
2929
+ tests that fail without the fix. The repository ships what agents need: the `@exhaustive-ui/mcp` server, the `exhaustive-ui` agent skill and the LLM docs, generated from this site.
1458
2930
 
1459
2931
  ## Pathway
1460
2932
 
1461
- ExhaustiveUI offers an organization structure involving contributors and the core team: Contributor Role After a certain period of frequent contributions, a community member is offered the Contributor role. On average, it may take about three months, but the exact duration can vary depending on the individual commitment. Committer Role If a contributor actively participates in the codebase and PRs, their role may be upgraded to a Committer level, providing direct commit access to the ExhaustiveUI codebase.
2933
+ ExhaustiveUI offers an organization structure involving contributors and the core team:
2934
+
2935
+ ### Contributor Role
2936
+
2937
+ After a certain period of frequent contributions, a community member is offered the Contributor role. On average, it may take about three months, but the exact duration can vary depending on the individual commitment.
2938
+
2939
+ ### Committer Role
2940
+
2941
+ If a contributor actively participates in the codebase and PRs, their role may be upgraded to a Committer level, providing direct commit access to the ExhaustiveUI codebase.
2942
+
2943
+ ## Benefits
2944
+
2945
+ Contributing to ExhaustiveUI comes with several benefits. Being part of an open-source project will enhance your career and open up exciting opportunities. You'll gain significant visibility in the developer community while improving
2946
+ yourself as a professional.
1462
2947
 
1463
2948
  ---
1464
2949