@odx/angular 6.0.0 → 6.1.0

package/esm2022/internal/translate/lib/translate.service.mjs

@@ -2,10 +2,33 @@ import { inject } from '@angular/core';
 import { LocalizationService } from '@odx/angular/localization';
 import { getLanguageCode } from '@odx/angular/utils';
 import { distinctUntilChanged, map, shareReplay, startWith } from 'rxjs';
+/**
+ * Service for translating keys into localized text. It listens to changes in the active language
+ * and provides translated strings based on the current language preference. The service uses
+ * provided `TranslationObject` containing the translations for each supported language.
+ *
+ * @example
+ * ```ts
+ * // Using TranslateService in a component
+ * class MyComponent {
+ *   constructor(private translateService: TranslateService) {
+ *     translateService.translate('greeting').subscribe(translatedText => {
+ *       console.log(translatedText); // Outputs "Hello" or "Bonjour" based on the active language
+ *     });
+ *   }
+ * }
+ * ```
+ */
 export class TranslateService {
     constructor(translations) {
         this.translations = translations;
         this.localizationService = inject(LocalizationService);
+        /**
+         * An observable that emits the current translation object based on the active language.
+         * It ensures that translations are updated dynamically whenever the user's language preference changes.
+         *
+         * @emits {TranslationObject} activeTranslation$ - The translation object for the active language.
+         */
         this.activeTranslation$ = this.localizationService.activeLanguage$.pipe(startWith(this.localizationService.defaultLanguage), distinctUntilChanged(), map((language) => {
             const languageCode = getLanguageCode(language);
             if (this.translations[language]) {
@@ -17,6 +40,12 @@ export class TranslateService {
             return this.translations[this.localizationService.defaultLanguage];
         }), shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Translates a key into its localized text, optionally replacing placeholders with dynamic values.
+     * @param {string} key - The translation key to translate.
+     * @param {Record<string, unknown>} [data={}] - An object mapping placeholder names to replacement values.
+     * @returns {Observable<string>} An observable emitting the translated text, with placeholders replaced by provided values.
+     */
     translate(key, data = {}) {
         return this.activeTranslation$.pipe(map((translation) => Object.entries(data).reduce((acc, [variableName, variable]) => {
             const variableRegex = RegExp(`{{\\s*${variableName}\\s*}}`, 'g');
@@ -24,4 +53,4 @@ export class TranslateService {
         }, translation[key] ?? '')));
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/controllers/controller.mjs

@@ -6,15 +6,40 @@ function controllerChanges(controllers) {
     const changes$ = pluckFromArray(controllers.filter(isPresent), 'change$');
     return changes$.length > 0 ? merge(...changes$) : EMPTY;
 }
+/**
+ * Sets up change detection for the provided controllers within the context of an Angular component or directive.
+ * It listens for changes from the specified controllers and triggers Angular's change detection mechanism in response.
+ *
+ * @param {...Array<Controller | undefined | null>} controllers - The controllers to monitor for changes.
+ * @returns {Observable<void>} An observable that emits whenever a change occurs in any of the provided controllers.
+ */
 export function detectControllerChanges(...controllers) {
     const changeDetector = inject(ChangeDetectorRef);
     return controllerChanges(controllers).pipe(tap(() => changeDetector.markForCheck()));
 }
+/**
+ * An abstract base class representing a controller that can notify observers of changes in its state.
+ * It provides lifecycle hooks for ngOnChanges and ngOnDestroy to manage its internal change observable.
+ */
 export class Controller {
     constructor() {
         this.change$$ = new Subject();
+        /**
+         * Represents an observable stream of changes.
+         * @readonly
+         */
         this.change$ = this.change$$.pipe(shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Sets up a controller instance to emit change events and trigger Angular change detection whenever
+     * the controller's state changes. It is a utility method that can be used to initialize controllers
+     * that are managed outside of Angular's DI system.
+     *
+     * @static
+     * @param {Controller | null} controller - The controller instance to set up.
+     * @param {ChangeDetectorRef} changeDetector - The Angular change detector reference to trigger change detection.
+     * @returns {Controller | null} The same controller instance for chaining or null if the controller is not provided.
+     */
     static setup(controller, changeDetector) {
         controllerChanges([controller])
             .pipe(tap(() => changeDetector.markForCheck()))
@@ -36,4 +61,4 @@ export class Controller {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Controller, decorators: [{
             type: Directive
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9zcmMvbGliL2NvbnRyb2xsZXJzL2NvbnRyb2xsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQXdCLE1BQU0sZUFBZSxDQUFDO0FBQzNGLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDL0QsT0FBTyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQWMsV0FBVyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBRTNFLFNBQVMsaUJBQWlCLENBQUMsV0FBaUQ7SUFDMUUsTUFBTSxRQUFRLEdBQUcsY0FBYyxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFFMUUsT0FBTyxRQUFRLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztBQUMxRCxDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLEdBQUcsV0FBaUQ7SUFDMUYsTUFBTSxjQUFjLEdBQUcsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFFakQsT0FBTyxpQkFBaUIsQ0FBQyxXQUFXLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLGNBQWMsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDdkYsQ0FBQztBQUVEOzs7R0FHRztBQUVILE1BQU0sT0FBZ0IsVUFBVTtJQURoQztRQUVtQixhQUFRLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUVoRDs7O1dBR0c7UUFDYSxZQUFPLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLEVBQUUsVUFBVSxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO0tBK0I5RjtJQTdCQzs7Ozs7Ozs7O09BU0c7SUFDSSxNQUFNLENBQUMsS0FBSyxDQUFDLFVBQTZCLEVBQUUsY0FBaUM7UUFDbEYsaUJBQWlCLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQzthQUM1QixJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLGNBQWMsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUFDO2FBQzlDLFNBQVMsRUFBRSxDQUFDO1FBRWYsT0FBTyxVQUFVLENBQUM7SUFDcEIsQ0FBQztJQUVNLFdBQVc7UUFDaEIsSUFBSSxDQUFDLHVCQUF1QixFQUFFLENBQUM7SUFDakMsQ0FBQztJQUVNLFdBQVc7UUFDaEIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRVMsdUJBQXVCO1FBQy9CLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDdkIsQ0FBQzsrR0FyQ21CLFVBQVU7bUdBQVYsVUFBVTs7NEZBQVYsVUFBVTtrQkFEL0IsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENoYW5nZURldGVjdG9yUmVmLCBEaXJlY3RpdmUsIGluamVjdCwgT25DaGFuZ2VzLCBPbkRlc3Ryb3kgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGlzUHJlc2VudCwgcGx1Y2tGcm9tQXJyYXkgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuaW1wb3J0IHsgRU1QVFksIG1lcmdlLCBPYnNlcnZhYmxlLCBzaGFyZVJlcGxheSwgU3ViamVjdCwgdGFwIH0gZnJvbSAncnhqcyc7XG5cbmZ1bmN0aW9uIGNvbnRyb2xsZXJDaGFuZ2VzKGNvbnRyb2xsZXJzOiBBcnJheTxDb250cm9sbGVyIHwgdW5kZWZpbmVkIHwgbnVsbD4pOiBPYnNlcnZhYmxlPHZvaWQ+IHtcbiAgY29uc3QgY2hhbmdlcyQgPSBwbHVja0Zyb21BcnJheShjb250cm9sbGVycy5maWx0ZXIoaXNQcmVzZW50KSwgJ2NoYW5nZSQnKTtcblxuICByZXR1cm4gY2hhbmdlcyQubGVuZ3RoID4gMCA/IG1lcmdlKC4uLmNoYW5nZXMkKSA6IEVNUFRZO1xufVxuXG4vKipcbiAqIFNldHMgdXAgY2hhbmdlIGRldGVjdGlvbiBmb3IgdGhlIHByb3ZpZGVkIGNvbnRyb2xsZXJzIHdpdGhpbiB0aGUgY29udGV4dCBvZiBhbiBBbmd1bGFyIGNvbXBvbmVudCBvciBkaXJlY3RpdmUuXG4gKiBJdCBsaXN0ZW5zIGZvciBjaGFuZ2VzIGZyb20gdGhlIHNwZWNpZmllZCBjb250cm9sbGVycyBhbmQgdHJpZ2dlcnMgQW5ndWxhcidzIGNoYW5nZSBkZXRlY3Rpb24gbWVjaGFuaXNtIGluIHJlc3BvbnNlLlxuICpcbiAqIEBwYXJhbSB7Li4uQXJyYXk8Q29udHJvbGxlciB8IHVuZGVmaW5lZCB8IG51bGw+fSBjb250cm9sbGVycyAtIFRoZSBjb250cm9sbGVycyB0byBtb25pdG9yIGZvciBjaGFuZ2VzLlxuICogQHJldHVybnMge09ic2VydmFibGU8dm9pZD59IEFuIG9ic2VydmFibGUgdGhhdCBlbWl0cyB3aGVuZXZlciBhIGNoYW5nZSBvY2N1cnMgaW4gYW55IG9mIHRoZSBwcm92aWRlZCBjb250cm9sbGVycy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRldGVjdENvbnRyb2xsZXJDaGFuZ2VzKC4uLmNvbnRyb2xsZXJzOiBBcnJheTxDb250cm9sbGVyIHwgdW5kZWZpbmVkIHwgbnVsbD4pOiBPYnNlcnZhYmxlPHZvaWQ+IHtcbiAgY29uc3QgY2hhbmdlRGV0ZWN0b3IgPSBpbmplY3QoQ2hhbmdlRGV0ZWN0b3JSZWYpO1xuXG4gIHJldHVybiBjb250cm9sbGVyQ2hhbmdlcyhjb250cm9sbGVycykucGlwZSh0YXAoKCkgPT4gY2hhbmdlRGV0ZWN0b3IubWFya0ZvckNoZWNrKCkpKTtcbn1cblxuLyoqXG4gKiBBbiBhYnN0cmFjdCBiYXNlIGNsYXNzIHJlcHJlc2VudGluZyBhIGNvbnRyb2xsZXIgdGhhdCBjYW4gbm90aWZ5IG9ic2VydmVycyBvZiBjaGFuZ2VzIGluIGl0cyBzdGF0ZS5cbiAqIEl0IHByb3ZpZGVzIGxpZmVjeWNsZSBob29rcyBmb3IgbmdPbkNoYW5nZXMgYW5kIG5nT25EZXN0cm95IHRvIG1hbmFnZSBpdHMgaW50ZXJuYWwgY2hhbmdlIG9ic2VydmFibGUuXG4gKi9cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIENvbnRyb2xsZXIgaW1wbGVtZW50cyBPbkNoYW5nZXMsIE9uRGVzdHJveSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgY2hhbmdlJCQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gIC8qKlxuICAgKiBSZXByZXNlbnRzIGFuIG9ic2VydmFibGUgc3RyZWFtIG9mIGNoYW5nZXMuXG4gICAqIEByZWFkb25seVxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IGNoYW5nZSQgPSB0aGlzLmNoYW5nZSQkLnBpcGUoc2hhcmVSZXBsYXkoeyBidWZmZXJTaXplOiAxLCByZWZDb3VudDogdHJ1ZSB9KSk7XG5cbiAgLyoqXG4gICAqIFNldHMgdXAgYSBjb250cm9sbGVyIGluc3RhbmNlIHRvIGVtaXQgY2hhbmdlIGV2ZW50cyBhbmQgdHJpZ2dlciBBbmd1bGFyIGNoYW5nZSBkZXRlY3Rpb24gd2hlbmV2ZXJcbiAgICogdGhlIGNvbnRyb2xsZXIncyBzdGF0ZSBjaGFuZ2VzLiBJdCBpcyBhIHV0aWxpdHkgbWV0aG9kIHRoYXQgY2FuIGJlIHVzZWQgdG8gaW5pdGlhbGl6ZSBjb250cm9sbGVyc1xuICAgKiB0aGF0IGFyZSBtYW5hZ2VkIG91dHNpZGUgb2YgQW5ndWxhcidzIERJIHN5c3RlbS5cbiAgICpcbiAgICogQHN0YXRpY1xuICAgKiBAcGFyYW0ge0NvbnRyb2xsZXIgfCBudWxsfSBjb250cm9sbGVyIC0gVGhlIGNvbnRyb2xsZXIgaW5zdGFuY2UgdG8gc2V0IHVwLlxuICAgKiBAcGFyYW0ge0NoYW5nZURldGVjdG9yUmVmfSBjaGFuZ2VEZXRlY3RvciAtIFRoZSBBbmd1bGFyIGNoYW5nZSBkZXRlY3RvciByZWZlcmVuY2UgdG8gdHJpZ2dlciBjaGFuZ2UgZGV0ZWN0aW9uLlxuICAgKiBAcmV0dXJucyB7Q29udHJvbGxlciB8IG51bGx9IFRoZSBzYW1lIGNvbnRyb2xsZXIgaW5zdGFuY2UgZm9yIGNoYWluaW5nIG9yIG51bGwgaWYgdGhlIGNvbnRyb2xsZXIgaXMgbm90IHByb3ZpZGVkLlxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBzZXR1cChjb250cm9sbGVyOiBDb250cm9sbGVyIHwgbnVsbCwgY2hhbmdlRGV0ZWN0b3I6IENoYW5nZURldGVjdG9yUmVmKTogQ29udHJvbGxlciB8IG51bGwge1xuICAgIGNvbnRyb2xsZXJDaGFuZ2VzKFtjb250cm9sbGVyXSlcbiAgICAgIC5waXBlKHRhcCgoKSA9PiBjaGFuZ2VEZXRlY3Rvci5tYXJrRm9yQ2hlY2soKSkpXG4gICAgICAuc3Vic2NyaWJlKCk7XG5cbiAgICByZXR1cm4gY29udHJvbGxlcjtcbiAgfVxuXG4gIHB1YmxpYyBuZ09uQ2hhbmdlcygpOiB2b2lkIHtcbiAgICB0aGlzLnRyaWdnZXJDb250cm9sbGVyQ2hhbmdlKCk7XG4gIH1cblxuICBwdWJsaWMgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgdGhpcy5jaGFuZ2UkJC5jb21wbGV0ZSgpO1xuICB9XG5cbiAgcHJvdGVjdGVkIHRyaWdnZXJDb250cm9sbGVyQ2hhbmdlKCkge1xuICAgIHRoaXMuY2hhbmdlJCQubmV4dCgpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/controllers/disabled.controller.mjs

@@ -4,22 +4,76 @@ import { Controller } from './controller';
 import * as i0 from "@angular/core";
 export const DISABLED_CONTROLLER = new InjectionToken('@odx/angular::DisabledWatchedController');
 export const DISABLED_INTERNAL_CONTROLLER = new InjectionToken('@odx/angular::DisabledController');
+/**
+ * Directive that provides hierarchical disabled state management for Angular components or directives.
+ * It allows for a disabled state to be inherited from parent components, facilitating the propagation
+ * of disabled states down component trees. This is particularly useful in forms or complex component
+ * structures where nested components need to respond to disabled states dynamically.
+ *
+ * The `DisabledController` works by injecting itself or a parent `DisabledController` instance to determine
+ * the effective disabled state, taking into account both its own state and that of its parents.
+ *
+ * Usage:
+ * Apply the `disabled` attribute, potentially bound to a component property, to use this directive.
+ * The directive can be automatically provided to the component's children by calling the `connect`
+ * static method in the component's providers array.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'app-custom-input',
+ *   templateUrl: './custom-input.component.html',
+ *   providers: [DisabledController.connect()],
+ *   standalone: true,
+ * })
+ * export class CustomInputComponent {
+ *   constructor(private disabledCtrl: DisabledController) {}
+ * }
+ * ```
+ * ```html
+ * <input [disabled]="disabledCtrl.disabled" />
+ * ```
+ */
 export class DisabledController extends Controller {
     constructor() {
         super(...arguments);
         this.parentController = inject(DISABLED_CONTROLLER, { optional: true, skipSelf: true });
         this.isDisabled = false;
+        /**
+         * A reactive representation of the current effective disabled state, considering both
+         * the controller's own state and that of its parent controllers.
+         *
+         * @emits {boolean} - The current disabled state.
+         */
         this.isDisabled$ = this.change$.pipe(map(() => this.disabled), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Sets the disabled state of the current controller. If the state changes, updates the internal
+     * flag.
+     * @param {boolean} value - The new disabled state to be applied.
+     */
     set disabled(value) {
         this.isDisabled = value;
     }
     get disabled() {
         return this.isDisabled || !!this.parentController?.disabled;
     }
+    /**
+     * Retrieves an instance of the `DisabledController` class from the dependency injection container.
+     * If the `DisabledController` is not registered in the container, it returns `null`.
+     *
+     * @returns {DisabledController | null} An instance of the `DisabledController` class or `null` if not found.
+     */
     static inject() {
         return inject(DISABLED_CONTROLLER, { optional: true });
     }
+    /**
+     * Static method to facilitate the injection of the `DisabledController` within Angular's DI system.
+     * This method provides a way to connect a component with its closest `DisabledController` parent,
+     * allowing for disabled state inheritance.
+     *
+     * @returns {Provider[]} An array of providers to enable disabled state management within a component.
+     */
     static connect() {
         return [
             {
@@ -34,6 +88,11 @@ export class DisabledController extends Controller {
             },
         ];
     }
+    /**
+     * Sets the disabled state of the current controller and triggers change detection if the state changes.
+     *
+     * @param {boolean} state - The new disabled state to be applied.
+     */
     setDisabledState(state) {
         if (this.disabled !== state) {
             this.disabled = state;
@@ -64,4 +123,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: [{ transform: booleanAttribute }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"disabled.controller.js","sourceRoot":"","sources":["../../../../../../libs/angular/src/lib/controllers/disabled.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { booleanAttribute, ChangeDetectorRef, Directive, forwardRef, Host, inject, InjectionToken, Input, Optional, Provider } from '@angular/core';\nimport { distinctUntilChanged, map, shareReplay } from 'rxjs';\nimport { Controller } from './controller';\n\nexport const DISABLED_CONTROLLER = new InjectionToken<DisabledController>('@odx/angular::DisabledWatchedController');\nexport const DISABLED_INTERNAL_CONTROLLER = new InjectionToken<DisabledController | null>('@odx/angular::DisabledController');\n\n/**\n * Directive that provides hierarchical disabled state management for Angular components or directives.\n * It allows for a disabled state to be inherited from parent components, facilitating the propagation\n * of disabled states down component trees. This is particularly useful in forms or complex component\n * structures where nested components need to respond to disabled states dynamically.\n *\n * The `DisabledController` works by injecting itself or a parent `DisabledController` instance to determine\n * the effective disabled state, taking into account both its own state and that of its parents.\n *\n * Usage:\n * Apply the `disabled` attribute, potentially bound to a component property, to use this directive.\n * The directive can be automatically provided to the component's children by calling the `connect`\n * static method in the component's providers array.\n *\n * @example\n * ```ts\n * @Component({\n *   selector: 'app-custom-input',\n *   templateUrl: './custom-input.component.html',\n *   providers: [DisabledController.connect()],\n *   standalone: true,\n * })\n * export class CustomInputComponent {\n *   constructor(private disabledCtrl: DisabledController) {}\n * }\n * ```\n * ```html\n * <input [disabled]=\"disabledCtrl.disabled\" />\n * ```\n */\n@Directive({\n  standalone: true,\n  selector: '[disabled]',\n  providers: [\n    {\n      provide: DISABLED_INTERNAL_CONTROLLER,\n      useExisting: forwardRef(() => DisabledController),\n    },\n  ],\n})\nexport class DisabledController extends Controller {\n  private readonly parentController = inject(DISABLED_CONTROLLER, { optional: true, skipSelf: true });\n  private isDisabled = false;\n\n  /**\n   * A reactive representation of the current effective disabled state, considering both\n   * the controller's own state and that of its parent controllers.\n   *\n   * @emits {boolean} - The current disabled state.\n   */\n  public readonly isDisabled$ = this.change$.pipe(\n    map(() => this.disabled),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Sets the disabled state of the current controller. If the state changes, updates the internal\n   * flag.\n   * @param {boolean} value - The new disabled state to be applied.\n   */\n  @Input({ transform: booleanAttribute })\n  public set disabled(value: boolean) {\n    this.isDisabled = value;\n  }\n\n  public get disabled(): boolean {\n    return this.isDisabled || !!this.parentController?.disabled;\n  }\n\n  /**\n   * Retrieves an instance of the `DisabledController` class from the dependency injection container.\n   * If the `DisabledController` is not registered in the container, it returns `null`.\n   *\n   * @returns {DisabledController | null} An instance of the `DisabledController` class or `null` if not found.\n   */\n  public static inject(): DisabledController | null {\n    return inject(DISABLED_CONTROLLER, { optional: true });\n  }\n\n  /**\n   * Static method to facilitate the injection of the `DisabledController` within Angular's DI system.\n   * This method provides a way to connect a component with its closest `DisabledController` parent,\n   * allowing for disabled state inheritance.\n   *\n   * @returns {Provider[]} An array of providers to enable disabled state management within a component.\n   */\n  public static connect(): Provider[] {\n    return [\n      {\n        provide: DISABLED_INTERNAL_CONTROLLER,\n        useFactory: (hostController: DisabledController | null) => hostController ?? new DisabledController(),\n        deps: [[new Optional(), new Host(), DisabledController]],\n      },\n      {\n        provide: DISABLED_CONTROLLER,\n        useFactory: Controller.setup,\n        deps: [[new Optional(), new Host(), DISABLED_INTERNAL_CONTROLLER], ChangeDetectorRef],\n      },\n    ];\n  }\n\n  /**\n   * Sets the disabled state of the current controller and triggers change detection if the state changes.\n   *\n   * @param {boolean} state - The new disabled state to be applied.\n   */\n  public setDisabledState(state: boolean): void {\n    if (this.disabled !== state) {\n      this.disabled = state;\n      this.ngOnChanges();\n    }\n  }\n}\n"]}

package/esm2022/lib/controllers/readonly.controller.mjs

@@ -9,7 +9,45 @@ const ELEMENTS_WITH_READONLY_ATTRIBUTE = {
 };
 export const READONLY_CONTROLLER = new InjectionToken('@odx/angular::ReadonlyWatchedController');
 export const READONLY_INTERNAL_CONTROLLER = new InjectionToken('@odx/angular::ReadonlyController');
+/**
+ * Directive to manage and propagate the readonly state within Angular components or directives,
+ * particularly useful for form elements like input, textarea, and select. It supports hierarchical
+ * readonly state management, allowing a parent component's readonly state to be inherited by its children.
+ *
+ * The directive leverages Angular's dependency injection system to access parent readonly controllers,
+ * enabling a cascading readonly state. This is beneficial in scenarios where a form or a part of it
+ * should become readonly based on certain conditions.
+ *
+ * Usage:
+ * Apply the `readonly` attribute, potentially bound to a component property, to use this directive.
+ * The directive can automatically provide itself to the component's children by calling the `connect`
+ * static method in the component's providers array.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'app-custom-input',
+ *   templateUrl: './custom-input.component.html',
+ *   providers: [ReadonlyController.connect()],
+ *   standalone: true,
+ * })
+ * export class CustomInputComponent {
+ *   constructor(private readonlyCtrl: ReadonlyController) {}
+ * }
+ * ```
+ *
+ * Template for CustomInputComponent with conditional readonly state:
+ * ```html
+ * <input [readonly]="readonlyCtrl.readonly" />
+ * ```
+ */
 export class ReadonlyController extends Controller {
+    /**
+     * Sets the readonly state of the current controller. If the state changes, updates the internal
+     * flag that controls the rendering of the `readonly` attribute in the host element.
+     *
+     * @param {boolean} value - The new readonly state to be applied.
+     */
     set readonly(value) {
         if (this.isReadonly === value)
             return;
@@ -24,12 +62,30 @@ export class ReadonlyController extends Controller {
         this.parentController = inject(READONLY_CONTROLLER, { optional: true, skipSelf: true });
         this.isReadonly = false;
         this.hasReadonlyAttribute = false;
+        /**
+         * An observable that emits the current value of the `isReadonly` property whenever it changes.
+         * The emitted values are distinct and replayed to new subscribers.
+         *
+         * @emits {boolean} The current readonly state of the controller.
+         */
         this.isReadonly$ = this.change$.pipe(map(() => this.isReadonly), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
         this.nodeName = element?.nativeElement.nodeName.toLowerCase() ?? '';
     }
+    /**
+     * Returns an instance of the ReadonlyController or null if it cannot be found.
+     *
+     * @returns {ReadonlyController | null} An instance of the ReadonlyController or null.
+     */
     static inject() {
         return inject(READONLY_CONTROLLER, { optional: true });
     }
+    /**
+     * Static method to facilitate the injection of the `ReadonlyController` within Angular's DI system.
+     * This method provides a way to connect a component with its closest `ReadonlyController` parent,
+     * allowing for readonly state inheritance.
+     *
+     * @returns {Provider} An array of providers to enable readonly state management within a component.
+     */
     static connect() {
         return [
             {
@@ -74,4 +130,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: [{ transform: booleanAttribute }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readonly.controller.js","sourceRoot":"","sources":["../../../../../../libs/angular/src/lib/controllers/readonly.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { booleanAttribute, ChangeDetectorRef, Directive, ElementRef, forwardRef, Host, inject, InjectionToken, Input, Optional, Provider } from '@angular/core';\nimport { distinctUntilChanged, map, shareReplay } from 'rxjs';\nimport { Controller } from './controller';\n\nconst ELEMENTS_WITH_READONLY_ATTRIBUTE = {\n  input: true,\n  textarea: true,\n  select: true,\n} as Record<string, boolean>;\n\nexport const READONLY_CONTROLLER = new InjectionToken<ReadonlyController>('@odx/angular::ReadonlyWatchedController');\nexport const READONLY_INTERNAL_CONTROLLER = new InjectionToken<ReadonlyController | null>('@odx/angular::ReadonlyController');\n\n/**\n * Directive to manage and propagate the readonly state within Angular components or directives,\n * particularly useful for form elements like input, textarea, and select. It supports hierarchical\n * readonly state management, allowing a parent component's readonly state to be inherited by its children.\n *\n * The directive leverages Angular's dependency injection system to access parent readonly controllers,\n * enabling a cascading readonly state. This is beneficial in scenarios where a form or a part of it\n * should become readonly based on certain conditions.\n *\n * Usage:\n * Apply the `readonly` attribute, potentially bound to a component property, to use this directive.\n * The directive can automatically provide itself to the component's children by calling the `connect`\n * static method in the component's providers array.\n *\n * @example\n * ```ts\n * @Component({\n *   selector: 'app-custom-input',\n *   templateUrl: './custom-input.component.html',\n *   providers: [ReadonlyController.connect()],\n *   standalone: true,\n * })\n * export class CustomInputComponent {\n *   constructor(private readonlyCtrl: ReadonlyController) {}\n * }\n * ```\n *\n * Template for CustomInputComponent with conditional readonly state:\n * ```html\n * <input [readonly]=\"readonlyCtrl.readonly\" />\n * ```\n */\n@Directive({\n  standalone: true,\n  selector: '[readonly]',\n  providers: [\n    {\n      provide: READONLY_INTERNAL_CONTROLLER,\n      useExisting: forwardRef(() => ReadonlyController),\n    },\n  ],\n  host: {\n    '[attr.readonly]': 'hasReadonlyAttribute || null',\n  },\n})\nexport class ReadonlyController extends Controller {\n  private readonly parentController = inject(READONLY_CONTROLLER, { optional: true, skipSelf: true });\n  private readonly nodeName: string;\n  private isReadonly = false;\n\n  protected hasReadonlyAttribute = false;\n\n  /**\n   * An observable that emits the current value of the `isReadonly` property whenever it changes.\n   * The emitted values are distinct and replayed to new subscribers.\n   *\n   * @emits {boolean} The current readonly state of the controller.\n   */\n  public readonly isReadonly$ = this.change$.pipe(\n    map(() => this.isReadonly),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Sets the readonly state of the current controller. If the state changes, updates the internal\n   * flag that controls the rendering of the `readonly` attribute in the host element.\n   *\n   * @param {boolean} value - The new readonly state to be applied.\n   */\n  @Input({ transform: booleanAttribute })\n  public set readonly(value: boolean) {\n    if (this.isReadonly === value) return;\n    this.isReadonly = value;\n    this.hasReadonlyAttribute = this.isReadonly && ELEMENTS_WITH_READONLY_ATTRIBUTE[this.nodeName];\n  }\n  public get readonly(): boolean {\n    return this.isReadonly || !!this.parentController?.readonly;\n  }\n\n  constructor(element: ElementRef<HTMLElement> | null) {\n    super();\n    this.nodeName = element?.nativeElement.nodeName.toLowerCase() ?? '';\n  }\n\n  /**\n   * Returns an instance of the ReadonlyController or null if it cannot be found.\n   *\n   * @returns {ReadonlyController | null} An instance of the ReadonlyController or null.\n   */\n  public static inject(): ReadonlyController | null {\n    return inject(READONLY_CONTROLLER, { optional: true });\n  }\n\n  /**\n   * Static method to facilitate the injection of the `ReadonlyController` within Angular's DI system.\n   * This method provides a way to connect a component with its closest `ReadonlyController` parent,\n   * allowing for readonly state inheritance.\n   *\n   * @returns {Provider} An array of providers to enable readonly state management within a component.\n   */\n  public static connect(): Provider {\n    return [\n      {\n        provide: READONLY_INTERNAL_CONTROLLER,\n        useFactory: (hostController: ReadonlyController | null, elementRef: ElementRef | null) => hostController ?? new ReadonlyController(elementRef),\n        deps: [\n          [new Optional(), new Host(), ReadonlyController],\n          [new Optional(), ElementRef],\n        ],\n      },\n      {\n        provide: READONLY_CONTROLLER,\n        useFactory: Controller.setup,\n        deps: [[new Optional(), new Host(), READONLY_INTERNAL_CONTROLLER], ChangeDetectorRef],\n      },\n    ];\n  }\n}\n"]}

package/esm2022/lib/directives/click-outside.directive.mjs

@@ -2,6 +2,25 @@ import { booleanAttribute, Directive, EventEmitter, inject, Input, Output, Rende
 import { deferFn, hasChanged, injectElement } from '@odx/angular/utils';
 import { debounceTime, NEVER, Observable, switchMap, tap } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * Directive to detect clicks outside of an element. When active, it listens for clicks outside
+ * the host element and emits an event through the `odxClickOutside` EventEmitter. This is useful
+ * for handling UI logic that depends on outside clicks, such as closing a dropdown or modal
+ * when the user clicks elsewhere on the page.
+ *
+ * Apply `odxClickOutside` to an element and bind an event handler to react to outside clicks.
+ * Optionally, use `[odxClickOutsideActive]="condition"` to enable or disable the detection dynamically.
+ *
+ * @example
+ * ```html
+ * <div
+ *   odxClickOutside
+ *   (odxClickOutside)="handleClickOutside()"
+ *   [odxClickOutsideActive]="isDropdownOpen">
+ *   <!-- Dropdown content -->
+ * </div>
+ * ```
+ */
 export class ClickOutsideDirective {
     constructor() {
         this.element = injectElement();
@@ -14,7 +33,17 @@ export class ClickOutsideDirective {
             const clickedOutside = hostElement.isConnected && targetElement.isConnected && !hostElement.contains(targetElement);
             return this.registerEventHandler('mouseup').pipe(debounceTime(0), tap(() => clickedOutside && this.odxClickOutside.emit(event)));
         }));
+        /**
+         * Controls whether the outside click detection is active. When `true`, the directive listens for outside clicks.
+         *
+         * @type {boolean}
+         */
         this.odxClickOutsideActive = true;
+        /**
+         * EventEmitter that emits the native Event object when an outside click is detected.
+         *
+         * @emits {Event}
+         */
         this.odxClickOutside = new EventEmitter();
     }
     ngOnInit() {
@@ -69,4 +98,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], odxClickOutside: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/delegate-focus.directive.mjs

@@ -1,8 +1,22 @@
 import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * A directive to manage focus within components. It emits events when the host component is focused,
+ * and dynamically updates the `tabindex` attribute to control focusability. This directive is particularly
+ * useful for custom components that require explicit focus management, such as custom input components
+ * or complex interactive components.
+ *
+ * The directive ensures that the component can be focused by setting `tabindex="0"`, making it reachable
+ * via keyboard navigation. When the component gains focus (`focusin`), it becomes non-focusable (`tabindex="-1"`)
+ * to manage focus delegation internally. It restores its focusability (`tabindex="0"`) when losing focus (`focusout`),
+ * allowing it to be focused again in the future.
+ */
 export class DelegateFocusDirective {
     constructor() {
         this.tabindex = 0;
+        /**
+         * Emits an event when the element is focused.
+         */
         this.focused = new EventEmitter();
     }
     handleFocus() {
@@ -37,4 +51,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: HostListener,
                 args: ['focusout']
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZWdhdGUtZm9jdXMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3NyYy9saWIvZGlyZWN0aXZlcy9kZWxlZ2F0ZS1mb2N1cy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFROUUsTUFBTSxPQUFPLHNCQUFzQjtJQU5uQztRQU9ZLGFBQVEsR0FBRyxDQUFDLENBQUM7UUFHaEIsWUFBTyxHQUFHLElBQUksWUFBWSxFQUFRLENBQUM7S0FnQjNDO0lBYlcsV0FBVztRQUNuQixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RCLENBQUM7SUFHUyxhQUFhO1FBQ3JCLElBQUksQ0FBQyxRQUFRLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUdTLGNBQWM7UUFDdEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxDQUFDLENBQUM7SUFDcEIsQ0FBQzsrR0FuQlUsc0JBQXNCO21HQUF0QixzQkFBc0I7OzRGQUF0QixzQkFBc0I7a0JBTmxDLFNBQVM7bUJBQUM7b0JBQ1QsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLElBQUksRUFBRTt3QkFDSixpQkFBaUIsRUFBRSxVQUFVO3FCQUM5QjtpQkFDRjs4QkFLUSxPQUFPO3NCQURiLE1BQU07Z0JBSUcsV0FBVztzQkFEcEIsWUFBWTt1QkFBQyxPQUFPO2dCQU1YLGFBQWE7c0JBRHRCLFlBQVk7dUJBQUMsU0FBUztnQkFNYixjQUFjO3NCQUR2QixZQUFZO3VCQUFDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEV2ZW50RW1pdHRlciwgSG9zdExpc3RlbmVyLCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGhvc3Q6IHtcbiAgICAnW2F0dHIudGFiaW5kZXhdJzogJ3RhYmluZGV4JyxcbiAgfSxcbn0pXG5leHBvcnQgY2xhc3MgRGVsZWdhdGVGb2N1c0RpcmVjdGl2ZSB7XG4gIHByb3RlY3RlZCB0YWJpbmRleCA9IDA7XG5cbiAgQE91dHB1dCgpXG4gIHB1YmxpYyBmb2N1c2VkID0gbmV3IEV2ZW50RW1pdHRlcjx2b2lkPigpO1xuXG4gIEBIb3N0TGlzdGVuZXIoJ2ZvY3VzJylcbiAgcHJvdGVjdGVkIGhhbmRsZUZvY3VzKCk6IHZvaWQge1xuICAgIHRoaXMuZm9jdXNlZC5uZXh0KCk7XG4gIH1cblxuICBASG9zdExpc3RlbmVyKCdmb2N1c2luJylcbiAgcHJvdGVjdGVkIGhhbmRsZUZvY3VzSW4oKTogdm9pZCB7XG4gICAgdGhpcy50YWJpbmRleCA9IC0xO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignZm9jdXNvdXQnKVxuICBwcm90ZWN0ZWQgaGFuZGxlRm9jdXNPdXQoKTogdm9pZCB7XG4gICAgdGhpcy50YWJpbmRleCA9IDA7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZWdhdGUtZm9jdXMuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3NyYy9saWIvZGlyZWN0aXZlcy9kZWxlZ2F0ZS1mb2N1cy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFOUU7Ozs7Ozs7Ozs7R0FVRztBQU9ILE1BQU0sT0FBTyxzQkFBc0I7SUFObkM7UUFPWSxhQUFRLEdBQUcsQ0FBQyxDQUFDO1FBRXZCOztXQUVHO1FBRUksWUFBTyxHQUFHLElBQUksWUFBWSxFQUFRLENBQUM7S0FnQjNDO0lBYlcsV0FBVztRQUNuQixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RCLENBQUM7SUFHUyxhQUFhO1FBQ3JCLElBQUksQ0FBQyxRQUFRLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUdTLGNBQWM7UUFDdEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxDQUFDLENBQUM7SUFDcEIsQ0FBQzsrR0F0QlUsc0JBQXNCO21HQUF0QixzQkFBc0I7OzRGQUF0QixzQkFBc0I7a0JBTmxDLFNBQVM7bUJBQUM7b0JBQ1QsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLElBQUksRUFBRTt3QkFDSixpQkFBaUIsRUFBRSxVQUFVO3FCQUM5QjtpQkFDRjs4QkFRUSxPQUFPO3NCQURiLE1BQU07Z0JBSUcsV0FBVztzQkFEcEIsWUFBWTt1QkFBQyxPQUFPO2dCQU1YLGFBQWE7c0JBRHRCLFlBQVk7dUJBQUMsU0FBUztnQkFNYixjQUFjO3NCQUR2QixZQUFZO3VCQUFDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEV2ZW50RW1pdHRlciwgSG9zdExpc3RlbmVyLCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBBIGRpcmVjdGl2ZSB0byBtYW5hZ2UgZm9jdXMgd2l0aGluIGNvbXBvbmVudHMuIEl0IGVtaXRzIGV2ZW50cyB3aGVuIHRoZSBob3N0IGNvbXBvbmVudCBpcyBmb2N1c2VkLFxuICogYW5kIGR5bmFtaWNhbGx5IHVwZGF0ZXMgdGhlIGB0YWJpbmRleGAgYXR0cmlidXRlIHRvIGNvbnRyb2wgZm9jdXNhYmlsaXR5LiBUaGlzIGRpcmVjdGl2ZSBpcyBwYXJ0aWN1bGFybHlcbiAqIHVzZWZ1bCBmb3IgY3VzdG9tIGNvbXBvbmVudHMgdGhhdCByZXF1aXJlIGV4cGxpY2l0IGZvY3VzIG1hbmFnZW1lbnQsIHN1Y2ggYXMgY3VzdG9tIGlucHV0IGNvbXBvbmVudHNcbiAqIG9yIGNvbXBsZXggaW50ZXJhY3RpdmUgY29tcG9uZW50cy5cbiAqXG4gKiBUaGUgZGlyZWN0aXZlIGVuc3VyZXMgdGhhdCB0aGUgY29tcG9uZW50IGNhbiBiZSBmb2N1c2VkIGJ5IHNldHRpbmcgYHRhYmluZGV4PVwiMFwiYCwgbWFraW5nIGl0IHJlYWNoYWJsZVxuICogdmlhIGtleWJvYXJkIG5hdmlnYXRpb24uIFdoZW4gdGhlIGNvbXBvbmVudCBnYWlucyBmb2N1cyAoYGZvY3VzaW5gKSwgaXQgYmVjb21lcyBub24tZm9jdXNhYmxlIChgdGFiaW5kZXg9XCItMVwiYClcbiAqIHRvIG1hbmFnZSBmb2N1cyBkZWxlZ2F0aW9uIGludGVybmFsbHkuIEl0IHJlc3RvcmVzIGl0cyBmb2N1c2FiaWxpdHkgKGB0YWJpbmRleD1cIjBcImApIHdoZW4gbG9zaW5nIGZvY3VzIChgZm9jdXNvdXRgKSxcbiAqIGFsbG93aW5nIGl0IHRvIGJlIGZvY3VzZWQgYWdhaW4gaW4gdGhlIGZ1dHVyZS5cbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGhvc3Q6IHtcbiAgICAnW2F0dHIudGFiaW5kZXhdJzogJ3RhYmluZGV4JyxcbiAgfSxcbn0pXG5leHBvcnQgY2xhc3MgRGVsZWdhdGVGb2N1c0RpcmVjdGl2ZSB7XG4gIHByb3RlY3RlZCB0YWJpbmRleCA9IDA7XG5cbiAgLyoqXG4gICAqIEVtaXRzIGFuIGV2ZW50IHdoZW4gdGhlIGVsZW1lbnQgaXMgZm9jdXNlZC5cbiAgICovXG4gIEBPdXRwdXQoKVxuICBwdWJsaWMgZm9jdXNlZCA9IG5ldyBFdmVudEVtaXR0ZXI8dm9pZD4oKTtcblxuICBASG9zdExpc3RlbmVyKCdmb2N1cycpXG4gIHByb3RlY3RlZCBoYW5kbGVGb2N1cygpOiB2b2lkIHtcbiAgICB0aGlzLmZvY3VzZWQubmV4dCgpO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignZm9jdXNpbicpXG4gIHByb3RlY3RlZCBoYW5kbGVGb2N1c0luKCk6IHZvaWQge1xuICAgIHRoaXMudGFiaW5kZXggPSAtMTtcbiAgfVxuXG4gIEBIb3N0TGlzdGVuZXIoJ2ZvY3Vzb3V0JylcbiAgcHJvdGVjdGVkIGhhbmRsZUZvY3VzT3V0KCk6IHZvaWQge1xuICAgIHRoaXMudGFiaW5kZXggPSAwO1xuICB9XG59XG4iXX0=