### File

`src/lib/directives/control-hide-show.directive.ts`

### Extends

`ExtractControlFromParentMixin` `ExtractFormDefinitionMixin`

### Implements

`OnInit` `OnDestroy`

### Metadata

Selector | `[rxapControlHideShow]`
Standalone | `true`

### Index

###### Properties

- Public control

###### Methods

- Protected extractControlFromParent

###### Inputs

- rxapControlHideShow

### Constructor

`constructor(renderer: Renderer2, elementRef: ElementRef, parent: ControlContainer | null, ngControl: NgControl | null)`
Defined in src/lib/directives/control-hide-show.directive.ts:85

Parameters :

Name | Type | Optional
renderer | `Renderer2` | No
elementRef | `ElementRef` | No
parent | `ControlContainer | null` | No
ngControl | `NgControl | null` | No

### Inputs

rxapControlHideShow
Type : `string`
Defined in src/lib/directives/control-hide-show.directive.ts:81

### Methods

Protected extractControlFromParent
`extractControlFromParent(parent: ControlContainer, controlPath: string)`
Inherited from `ExtractControlFromParentMixin`
Defined in `ExtractControlFromParentMixin:12`

Parameters :

Name | Type | Optional
parent | `ControlContainer` | No
controlPath | `string` | No

Returns : `AbstractControl`

### Properties

Public control
Type : `RxapFormControl`
Defined in src/lib/directives/control-hide-show.directive.ts:83

    import {
      Directive,
      ElementRef,
      Inject,
      Input,
      OnDestroy,
      OnInit,
      Optional,
      Renderer2,
      Self,
    } from '@angular/core';
    import {
      AbstractControl,
      FormDefinition,
      RxapFormControl,
    } from '@rxap/forms';
    import {
      ControlContainer,
      NgControl,
    } from '@angular/forms';
    import { Mixin } from '@rxap/mixin';
    import {
      of,
      Subscription,
    } from 'rxjs';
    import {
      catchError,
      startWith,
      tap,
    } from 'rxjs/operators';
    import { ExtractControlFromParentMixin } from '../mixins/extract-control-from-parent.mixin';
    import { ExtractFormDefinitionMixin } from '../mixins/extract-form-definition.mixin';
    import {
      getMetadata,
      setMetadataMap,
    } from '@rxap/reflect-metadata';

    export const RXAP_FORM_SYSTEM_SHOW_METADATA = 'rxap/form-system/show-function';
    export const RXAP_FORM_SYSTEM_HIDE_METADATA = 'rxap/form-system/hide-function';
    export const RXAP_FORM_SYSTEM_HIDE_SHOW_OPTIONS = 'rxap/form-system/hide-show-options';

    export type ControlHideShowFunction<T = any> = (this: T, control: AbstractControl) => boolean | null;

    export interface ControlHideShowOptions {
      /**
       * Weather the hide/showFunction should be called on root group changes
       */
      rootChange?: boolean;
    }

    export function UseHideFunction(hideFunction: ControlHideShowFunction, options: ControlHideShowOptions = {}) {
      return function (target: any, propertyKey: string) {
        setMetadataMap(propertyKey, hideFunction, RXAP_FORM_SYSTEM_HIDE_METADATA, target);
        if (Object.keys(options).length) {
          setMetadataMap(propertyKey, options, RXAP_FORM_SYSTEM_HIDE_SHOW_OPTIONS, target);
        }
      };
    }

    export function UseShowFunction(showFunction: ControlHideShowFunction, options: ControlHideShowOptions = {}) {
      return function (target: any, propertyKey: string) {
        setMetadataMap(propertyKey, showFunction, RXAP_FORM_SYSTEM_SHOW_METADATA, target);
        if (Object.keys(options).length) {
          setMetadataMap(propertyKey, options, RXAP_FORM_SYSTEM_HIDE_SHOW_OPTIONS, target);
        }
      };
    }

    export interface ControlHideShowDirective extends ExtractControlFromParentMixin,
                                                      ExtractFormDefinitionMixin {
    }

    @Mixin(ExtractControlFromParentMixin, ExtractFormDefinitionMixin)
    @Directive({
      selector: '[rxapControlHideShow]',
      standalone: true,
    })
    export class ControlHideShowDirective implements OnInit, OnDestroy {

      @Input('rxapControlHideShow')
      public controlId?: string;

      public control!: RxapFormControl;

      private subscription = new Subscription();

      constructor(
        @Inject(Renderer2)
        private readonly renderer: Renderer2,
        @Inject(ElementRef)
        private readonly elementRef: ElementRef,
        @Optional()
        @Inject(ControlContainer)
        private readonly parent: ControlContainer | null,
        @Self()
        @Optional()
        @Inject(NgControl)
        private readonly ngControl: NgControl | null,
      ) {
      }

      public ngOnInit() {

        if (!this.ngControl && !this.parent) {
          throw new Error('Easier the ControlContainer or NgControl must be injectable');
        }

        if (!this.ngControl && !this.controlId) {
          throw new Error('If the NgControl is not injectable then the control id must be defined!');
        }

        const control = this.ngControl?.control ?? this.extractControlFromParent(this.parent!, this.controlId!);

        if (!(control instanceof RxapFormControl)) {
          throw new Error('The control is not an instance of RxapFormControl');
        }

        this.control = control;

        const formDefinition = this.extractFormDefinition(control);

        const hideFunction = this.extractHideFunction(formDefinition);

        const showFunction = this.extractShowFunction(formDefinition);

        const options = this.extractOptions(formDefinition);

        let changeTrigger = formDefinition.rxapFormGroup.valueChanges;

        if (options.rootChange) {
          changeTrigger = formDefinition.rxapFormGroup.root.valueChanges;
        }

        changeTrigger = changeTrigger.pipe(startWith(null));

        if (showFunction) {
          this.subscription.add(
            changeTrigger.pipe(
              tap(() => {
                // TODO : resubscribe if the showFunction throws an error
                const show = showFunction.call(formDefinition, control);

                switch (show) {

                  case true:
                    this.show();
                    break;

                  case false:
                    this.hide();
                    break;

                  case null:
                    this.reset();
                    break;

                }

              }),
              catchError(err => {
                console.error(err);
                return of(null);
              }),
            ).subscribe(),
          );
        }

        if (hideFunction) {
          this.subscription.add(
            changeTrigger.pipe(
              tap(() => {
                // TODO : resubscribe if the hideFunction throws an error
                const hide = hideFunction.call(formDefinition, control);

                switch (hide) {

                  case true:
                    this.hide();
                    break;

                  case false:
                    this.show();
                    break;

                  case null:
                    this.reset();
                    break;

                }

              }),
              catchError(err => {
                console.error(err);
                return of(null);
              }),
            ).subscribe(),
          );
        }

      }

      public ngOnDestroy() {
        this.subscription.unsubscribe();
      }

      private extractOptions(formDefinition: FormDefinition): ControlHideShowOptions {
        const map = getMetadata<Map<string, ControlHideShowOptions>>(
          RXAP_FORM_SYSTEM_HIDE_SHOW_OPTIONS,
          Object.getPrototypeOf(formDefinition),
        ) ?? null;

        if (!map || !map.has(this.control.controlId)) {
          return {};
        }

        return map.get(this.control.controlId)!;

      }

      private extractHideFunction(formDefinition: FormDefinition): ControlHideShowFunction | null {
        const map = getMetadata<Map<string, ControlHideShowFunction>>(
          RXAP_FORM_SYSTEM_HIDE_METADATA,
          Object.getPrototypeOf(formDefinition),
        ) ?? null;

        if (!map || !map.has(this.control.controlId)) {
          return null;
        }

        return map.get(this.control.controlId)!;

      }

      private extractShowFunction(formDefinition: FormDefinition): ControlHideShowFunction | null {
        const map = getMetadata<Map<string, ControlHideShowFunction>>(
          RXAP_FORM_SYSTEM_SHOW_METADATA,
          Object.getPrototypeOf(formDefinition),
        ) ?? null;

        if (!map || !map.has(this.control.controlId)) {
          return null;
        }

        return map.get(this.control.controlId)!;

      }

      private hide() {
        this.renderer.setStyle(this.elementRef.nativeElement, 'display', 'none');
      }

      private show() {
        this.renderer.setStyle(this.elementRef.nativeElement, 'display', 'block');
      }

      private reset() {
        this.renderer.removeStyle(this.elementRef.nativeElement, 'display');
      }

    }

# results matching ""

# No results matching ""