ng-jhipster

  • Version 0.16.0
  • Published
  • 1.26 MB
  • 1 dependency
  • Apache-2.0 license

Install

npm i ng-jhipster
yarn add ng-jhipster
pnpm add ng-jhipster

Overview

A Jhipster util library for Angular

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ɵa

const ɵa: (
| typeof JhiFilterPipe
| typeof JhiOrderByPipe
| typeof JhiTruncateCharactersPipe
)[];

    variable ɵb

    const ɵb: (
    | typeof JhiMaxbytesValidatorDirective
    | typeof JhiMinbytesValidatorDirective
    | typeof JhiMaxValidatorDirective
    | typeof JhiMinValidatorDirective
    | typeof JhiSortDirective
    | typeof JhiSortByDirective
    )[];

      variable ɵc

      const ɵc: (
      | typeof JhiItemCountComponent
      | typeof JhiBooleanComponent
      | typeof JhiJvmMemoryComponent
      | typeof JhiThreadModalComponent
      | typeof JhiJvmThreadsComponent
      | typeof JhiMetricsHttpRequestComponent
      | typeof JhiMetricsEndpointsRequestsComponent
      | typeof JhiMetricsCacheComponent
      | typeof JhiMetricsDatasourceComponent
      | typeof JhiMetricsSystemComponent
      | typeof JhiMetricsGarbageCollectorComponent
      )[];

        Functions

        function missingTranslationHandler

        missingTranslationHandler: (
        configService: JhiConfigService
        ) => JhiMissingTranslationHandler;

          function translatePartialLoader

          translatePartialLoader: (http: any) => any;

            Classes

            class JhiAlertService

            class JhiAlertService {}

              constructor

              constructor(
              sanitizer: any,
              configService: JhiConfigService,
              ngZone: any,
              translateService: any
              );

                method addAlert

                addAlert: (alertOptions: JhiAlert, extAlerts: JhiAlert[]) => JhiAlert;

                  method clear

                  clear: () => void;

                    method closeAlert

                    closeAlert: (id: number, extAlerts?: JhiAlert[]) => JhiAlert[];

                      method closeAlertByIndex

                      closeAlertByIndex: (index: number, thisAlerts: JhiAlert[]) => JhiAlert[];

                        method error

                        error: (msg: string, params?: any, position?: string) => JhiAlert;

                          method get

                          get: () => JhiAlert[];

                            method info

                            info: (msg: string, params?: any, position?: string) => JhiAlert;

                              method isToast

                              isToast: () => boolean;

                                method success

                                success: (msg: string, params?: any, position?: string) => JhiAlert;

                                  method warning

                                  warning: (msg: string, params?: any, position?: string) => JhiAlert;

                                    class JhiBase64Service

                                    class JhiBase64Service {}

                                      method decode

                                      decode: (input: any) => string;

                                        method encode

                                        encode: (input: any) => string;

                                          class JhiBooleanComponent

                                          class JhiBooleanComponent implements OnInit {}
                                          • This component can be used to display a boolean value by defining the attributes If an attribute is not provided, default values will be applied (see JhiModuleConfig class) Have a look at the following examples

                                            * * * * * * * * * * * * * * * * * * * * * * * * * * *

                                            <jhi-boolean [value]="inputBooleanVariable">

                                            - Display a green check when inputBooleanVariable is true - Display a red cross when inputBooleanVariable is false

                                            * * * * * * * * * * * * * * * * * * * * * * * * * * *

                                            <jhi-boolean [value]="inputBooleanVariable"> classTrue="fa fa-lg fa-check text-primary" classFalse="fa fa-lg fa-times text-warning"

                                            - Display a blue check when inputBooleanVariable is true - Display an orange cross when inputBooleanVariable is false

                                            * * * * * * * * * * * * * * * * * * * * * * * * * * *

                                            <jhi-boolean [value]="inputBooleanVariable"> classTrue="fa fa-lg fa-check" classFalse=""

                                            - Display a black check when inputBooleanVariable is true - Do not display anything when inputBooleanVariable is false

                                            * * * * * * * * * * * * * * * * * * * * * * * * * * *

                                            <jhi-boolean [value]="inputBooleanVariable" [textTrue]="'userManagement.activated' | translate" textFalse="deactivated">

                                            - Display a green badge when inputBooleanVariable is true - Display a red badge when inputBooleanVariable is false

                                            * * * * * * * * * * * * * * * * * * * * * * * * * * *

                                            <jhi-boolean [value]="user.activated" classTrue="badge badge-warning" classFalse="badge badge-info" [textTrue]="'userManagement.activated' | translate" textFalse="deactivated">

                                            - Display an orange badge and write 'activated' when inputBooleanVariable is true - Display a blue badge and write 'deactivated' when inputBooleanVariable is false

                                          constructor

                                          constructor(configService: JhiConfigService);

                                            property classFalse

                                            classFalse: string;
                                            • the class(es) (space separated) that will be applied if the input value is false

                                            property classTrue

                                            classTrue: string;
                                            • the class(es) (space separated) that will be applied if value is true

                                            property config

                                            config: JhiModuleConfig;

                                              property textFalse

                                              textFalse: string;
                                              • the text that will be displayed if the input value is false

                                              property textTrue

                                              textTrue: string;
                                              • the text that will be displayed if the input value is true

                                              property value

                                              value: boolean;
                                              • the boolean input value

                                              method ngOnInit

                                              ngOnInit: () => void;

                                                class JhiCapitalizePipe

                                                class JhiCapitalizePipe implements PipeTransform {}

                                                  method transform

                                                  transform: (input: string) => string;

                                                    class JhiConfigService

                                                    class JhiConfigService {}

                                                      constructor

                                                      constructor(moduleConfig?: JhiModuleConfig);

                                                        property CONFIG_OPTIONS

                                                        CONFIG_OPTIONS: JhiModuleConfig;

                                                          method getConfig

                                                          getConfig: () => JhiModuleConfig;

                                                            class JhiDataUtils

                                                            class JhiDataUtils {}
                                                            • An utility service for data.

                                                            constructor

                                                            constructor();

                                                              method abbreviate

                                                              abbreviate: (text: string, append?: string) => string;
                                                              • Method to abbreviate the text given

                                                              method byteSize

                                                              byteSize: (base64String: string) => string;
                                                              • Method to find the byte size of the string provides

                                                              method clearInputImage

                                                              clearInputImage: (
                                                              entity: any,
                                                              elementRef: any,
                                                              field: string,
                                                              fieldContentType: string,
                                                              idInput: string
                                                              ) => void;
                                                              • Method to clear the input

                                                              method downloadFile

                                                              downloadFile: (contentType: string, data: string, fileName: string) => void;
                                                              • Method to download file

                                                              method loadFileToForm

                                                              loadFileToForm: (
                                                              event: Event,
                                                              editForm: any,
                                                              field: string,
                                                              isImage: boolean
                                                              ) => any;
                                                              • Sets the base 64 data & file type of the 1st file on the event (event.target.files[0]) in the passed entity object and returns an observable.

                                                                Parameter event

                                                                the object containing the file (at event.target.files[0])

                                                                Parameter editForm

                                                                the form group where the input field is located

                                                                Parameter field

                                                                the field name to set the file's 'base 64 data' on

                                                                Parameter isImage

                                                                boolean representing if the file represented by the event is an image

                                                                Returns

                                                                an observable that loads file to form field and completes if sussessful or returns error as JhiFileLoadError on failure

                                                              method openFile

                                                              openFile: (contentType: string, data: string) => void;
                                                              • Method to open file

                                                              method setFileData

                                                              setFileData: (
                                                              event: any,
                                                              entity: any,
                                                              field: string,
                                                              isImage: boolean
                                                              ) => Promise<any>;
                                                              • Sets the base 64 data & file type of the 1st file on the event (event.target.files[0]) in the passed entity object and returns a promise.

                                                                Parameter event

                                                                the object containing the file (at event.target.files[0])

                                                                Parameter entity

                                                                the object to set the file's 'base 64 data' and 'file type' on

                                                                Parameter field

                                                                the field name to set the file's 'base 64 data' on

                                                                Parameter isImage

                                                                boolean representing if the file represented by the event is an image

                                                                Returns

                                                                a promise that resolves to the modified entity if operation is successful, otherwise rejects with an error message

                                                              method toBase64

                                                              toBase64: (file: File, cb: Function) => void;
                                                              • Method to convert the file to base64

                                                              class JhiDateUtils

                                                              class JhiDateUtils {}
                                                              • An utility service for date.

                                                              constructor

                                                              constructor();

                                                                method convertDateTimeFromServer

                                                                convertDateTimeFromServer: (date: any) => Date;
                                                                • Method to convert the date time from server into JS date object

                                                                method convertLocalDateFromServer

                                                                convertLocalDateFromServer: (date: any) => Date;
                                                                • Method to convert the date from server into JS date object

                                                                method convertLocalDateToServer

                                                                convertLocalDateToServer: (date: any, pattern?: string) => string;
                                                                • Method to convert the JS date object into specified date pattern

                                                                method dateformat

                                                                dateformat: () => string;
                                                                • Method to get the default date pattern

                                                                method toDate

                                                                toDate: (date: any) => Date;

                                                                  class JhiEventManager

                                                                  class JhiEventManager {}
                                                                  • An utility class to manage RX events

                                                                  constructor

                                                                  constructor();

                                                                    property observable

                                                                    observable: any;

                                                                      property observer

                                                                      observer: any;

                                                                        method broadcast

                                                                        broadcast: (event: JhiEventWithContent<any> | string) => void;
                                                                        • Method to broadcast the event to observer

                                                                        method destroy

                                                                        destroy: (subscriber: any) => void;
                                                                        • Method to unsubscribe the subscription

                                                                        method subscribe

                                                                        subscribe: (eventName: string, callback: any) => any;
                                                                        • Method to subscribe to an event with callback

                                                                        class JhiEventWithContent

                                                                        class JhiEventWithContent<T> {}

                                                                          constructor

                                                                          constructor(name: string, content: {});

                                                                            property content

                                                                            content: {};

                                                                              property name

                                                                              name: string;

                                                                                class JhiFilterPipe

                                                                                class JhiFilterPipe implements PipeTransform {}

                                                                                  method transform

                                                                                  transform: (input: any[], filter: any, field?: string) => any;

                                                                                    class JhiItemCountComponent

                                                                                    class JhiItemCountComponent {}
                                                                                    • A component that will take care of item count statistics of a pagination.

                                                                                    constructor

                                                                                    constructor(config: JhiConfigService);

                                                                                      property i18nEnabled

                                                                                      i18nEnabled: boolean;
                                                                                      • True if the generated application use i18n

                                                                                      property itemsPerPage

                                                                                      itemsPerPage: number;
                                                                                      • Number of items per page.

                                                                                      property page

                                                                                      page: number;
                                                                                      • current page number.

                                                                                      property total

                                                                                      total: number;
                                                                                      • Total number of items.

                                                                                      method i18nValues

                                                                                      i18nValues: () => Object;
                                                                                      • "translate-values" JSON of the template

                                                                                      class JhiKeysPipe

                                                                                      class JhiKeysPipe implements PipeTransform {}

                                                                                        method transform

                                                                                        transform: (value: any) => any;

                                                                                          class JhiLanguageService

                                                                                          class JhiLanguageService {}

                                                                                            constructor

                                                                                            constructor(translateService: any, configService: JhiConfigService);

                                                                                              property currentLang

                                                                                              currentLang: string;

                                                                                                method changeLanguage

                                                                                                changeLanguage: (languageKey: string) => void;

                                                                                                  method getCurrent

                                                                                                  getCurrent: () => Promise<string>;
                                                                                                  • Deprecated

                                                                                                    Will be removed when releasing generator-jhipster v7

                                                                                                  method getCurrentLanguage

                                                                                                  getCurrentLanguage: () => string;

                                                                                                    method init

                                                                                                    init: () => void;

                                                                                                      class JhiMaxbytesValidatorDirective

                                                                                                      class JhiMaxbytesValidatorDirective {}

                                                                                                        constructor

                                                                                                        constructor();

                                                                                                          property jhiMaxbytes

                                                                                                          jhiMaxbytes: number;

                                                                                                            method validate

                                                                                                            validate: (c: any) => { maxbytes: { valid: boolean } };

                                                                                                              class JhiMaxValidatorDirective

                                                                                                              class JhiMaxValidatorDirective {}

                                                                                                                constructor

                                                                                                                constructor();

                                                                                                                  property jhiMax

                                                                                                                  jhiMax: number;

                                                                                                                    method validate

                                                                                                                    validate: (c: any) => { max: { valid: boolean } };

                                                                                                                      class JhiMinbytesValidatorDirective

                                                                                                                      class JhiMinbytesValidatorDirective {}

                                                                                                                        constructor

                                                                                                                        constructor();

                                                                                                                          property jhiMinbytes

                                                                                                                          jhiMinbytes: number;

                                                                                                                            method validate

                                                                                                                            validate: (c: any) => { minbytes: { valid: boolean } };

                                                                                                                              class JhiMinValidatorDirective

                                                                                                                              class JhiMinValidatorDirective {}

                                                                                                                                constructor

                                                                                                                                constructor();

                                                                                                                                  property jhiMin

                                                                                                                                  jhiMin: number;

                                                                                                                                    method validate

                                                                                                                                    validate: (c: any) => { min: { valid: boolean } };

                                                                                                                                      class JhiMissingTranslationHandler

                                                                                                                                      class JhiMissingTranslationHandler implements MissingTranslationHandler {}

                                                                                                                                        constructor

                                                                                                                                        constructor(configService: JhiConfigService);

                                                                                                                                          method handle

                                                                                                                                          handle: (params: any) => string;

                                                                                                                                            class JhiModuleConfig

                                                                                                                                            class JhiModuleConfig {}

                                                                                                                                              property alertAsToast

                                                                                                                                              alertAsToast?: boolean;

                                                                                                                                                property alertTimeout

                                                                                                                                                alertTimeout?: number;

                                                                                                                                                  property classBadgeFalse

                                                                                                                                                  classBadgeFalse?: string;

                                                                                                                                                    property classBadgeTrue

                                                                                                                                                    classBadgeTrue?: string;

                                                                                                                                                      property classFalse

                                                                                                                                                      classFalse?: string;

                                                                                                                                                        property classTrue

                                                                                                                                                        classTrue?: string;

                                                                                                                                                          property defaultI18nLang

                                                                                                                                                          defaultI18nLang?: string;

                                                                                                                                                            property i18nEnabled

                                                                                                                                                            i18nEnabled?: boolean;

                                                                                                                                                              property noi18nMessage

                                                                                                                                                              noi18nMessage?: string;

                                                                                                                                                                property sortAscIcon

                                                                                                                                                                sortAscIcon?: any;

                                                                                                                                                                  property sortDescIcon

                                                                                                                                                                  sortDescIcon?: any;

                                                                                                                                                                    property sortIcon

                                                                                                                                                                    sortIcon?: any;

                                                                                                                                                                      class JhiOrderByPipe

                                                                                                                                                                      class JhiOrderByPipe implements PipeTransform {}

                                                                                                                                                                        method transform

                                                                                                                                                                        transform: (values: any[], predicate?: string, reverse?: boolean) => any;

                                                                                                                                                                          class JhiPaginationUtil

                                                                                                                                                                          class JhiPaginationUtil {}
                                                                                                                                                                          • An utility service for pagination

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor();

                                                                                                                                                                            method parseAscending

                                                                                                                                                                            parseAscending: (sort: string) => boolean;
                                                                                                                                                                            • Method to find whether the sort is defined

                                                                                                                                                                            method parsePage

                                                                                                                                                                            parsePage: (page: string) => number;
                                                                                                                                                                            • Method to query params are strings, and need to be parsed

                                                                                                                                                                            method parsePredicate

                                                                                                                                                                            parsePredicate: (sort: string) => string;
                                                                                                                                                                            • Method to sort can be in the format id,asc or id

                                                                                                                                                                            class JhiParseLinks {}
                                                                                                                                                                            • An utility service for link parsing.

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor();

                                                                                                                                                                              method parse

                                                                                                                                                                              parse: (header: string) => any;
                                                                                                                                                                              • Method to parse the links

                                                                                                                                                                              class JhiPureFilterPipe

                                                                                                                                                                              class JhiPureFilterPipe extends JhiFilterPipe implements PipeTransform {}

                                                                                                                                                                                method transform

                                                                                                                                                                                transform: (input: any[], filter: any, field?: string) => any;

                                                                                                                                                                                  class JhiResolvePagingParams

                                                                                                                                                                                  class JhiResolvePagingParams implements Resolve<any> {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(paginationUtil: JhiPaginationUtil);

                                                                                                                                                                                      method resolve

                                                                                                                                                                                      resolve: (
                                                                                                                                                                                      route: any,
                                                                                                                                                                                      state: any
                                                                                                                                                                                      ) => { page: number; predicate: string; ascending: boolean };

                                                                                                                                                                                        class JhiSortByDirective

                                                                                                                                                                                        class JhiSortByDirective implements AfterContentInit {}

                                                                                                                                                                                          constructor

                                                                                                                                                                                          constructor(jhiSort: JhiSortDirective, configService: JhiConfigService);

                                                                                                                                                                                            property iconComponent

                                                                                                                                                                                            iconComponent: any;

                                                                                                                                                                                              property jhiSortBy

                                                                                                                                                                                              jhiSortBy: string;

                                                                                                                                                                                                property sortAscIcon

                                                                                                                                                                                                sortAscIcon: any;

                                                                                                                                                                                                  property sortDescIcon

                                                                                                                                                                                                  sortDescIcon: any;

                                                                                                                                                                                                    property sortIcon

                                                                                                                                                                                                    sortIcon: any;

                                                                                                                                                                                                      method ngAfterContentInit

                                                                                                                                                                                                      ngAfterContentInit: () => void;

                                                                                                                                                                                                        method onClick

                                                                                                                                                                                                        onClick: () => void;

                                                                                                                                                                                                          class JhiSortDirective

                                                                                                                                                                                                          class JhiSortDirective {}

                                                                                                                                                                                                            constructor

                                                                                                                                                                                                            constructor();

                                                                                                                                                                                                              property activeIconComponent

                                                                                                                                                                                                              activeIconComponent: any;

                                                                                                                                                                                                                property ascending

                                                                                                                                                                                                                ascending: boolean;

                                                                                                                                                                                                                  property ascendingChange

                                                                                                                                                                                                                  ascendingChange: any;

                                                                                                                                                                                                                    property callback

                                                                                                                                                                                                                    callback: Function;

                                                                                                                                                                                                                      property predicate

                                                                                                                                                                                                                      predicate: string;

                                                                                                                                                                                                                        property predicateChange

                                                                                                                                                                                                                        predicateChange: any;

                                                                                                                                                                                                                          method sort

                                                                                                                                                                                                                          sort: (field: string) => void;

                                                                                                                                                                                                                            class JhiTranslateDirective

                                                                                                                                                                                                                            class JhiTranslateDirective implements OnChanges, OnInit, OnDestroy {}
                                                                                                                                                                                                                            • A wrapper directive on top of the translate pipe as the inbuilt translate directive from ngx-translate is too verbose and buggy

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor(configService: JhiConfigService, el: any, translateService: any);

                                                                                                                                                                                                                              property jhiTranslate

                                                                                                                                                                                                                              jhiTranslate: string;

                                                                                                                                                                                                                                property translateValues

                                                                                                                                                                                                                                translateValues: any;

                                                                                                                                                                                                                                  method ngOnChanges

                                                                                                                                                                                                                                  ngOnChanges: () => void;

                                                                                                                                                                                                                                    method ngOnDestroy

                                                                                                                                                                                                                                    ngOnDestroy: () => void;

                                                                                                                                                                                                                                      method ngOnInit

                                                                                                                                                                                                                                      ngOnInit: () => void;

                                                                                                                                                                                                                                        class JhiTruncateCharactersPipe

                                                                                                                                                                                                                                        class JhiTruncateCharactersPipe implements PipeTransform {}

                                                                                                                                                                                                                                          method transform

                                                                                                                                                                                                                                          transform: (input: string, chars: number, breakOnWord?: boolean) => string;

                                                                                                                                                                                                                                            class JhiTruncateWordsPipe

                                                                                                                                                                                                                                            class JhiTruncateWordsPipe implements PipeTransform {}

                                                                                                                                                                                                                                              method transform

                                                                                                                                                                                                                                              transform: (input: string, words: number) => string;

                                                                                                                                                                                                                                                class NgJhipsterModule

                                                                                                                                                                                                                                                class NgJhipsterModule {}

                                                                                                                                                                                                                                                  method forRoot

                                                                                                                                                                                                                                                  static forRoot: (moduleConfig: JhiModuleConfig) => any;

                                                                                                                                                                                                                                                    class ɵd

                                                                                                                                                                                                                                                    class JhiJvmMemoryComponent {}

                                                                                                                                                                                                                                                      property jvmMemoryMetrics

                                                                                                                                                                                                                                                      jvmMemoryMetrics: {};
                                                                                                                                                                                                                                                      • object containing all jvm memory metrics

                                                                                                                                                                                                                                                      property updating

                                                                                                                                                                                                                                                      updating: boolean;
                                                                                                                                                                                                                                                      • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                      class ɵe

                                                                                                                                                                                                                                                      class JhiJvmThreadsComponent implements OnInit {}

                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                        constructor(modalService: any);

                                                                                                                                                                                                                                                          property threadData

                                                                                                                                                                                                                                                          threadData: any;
                                                                                                                                                                                                                                                          • object containing thread related metrics

                                                                                                                                                                                                                                                          property threadStats

                                                                                                                                                                                                                                                          threadStats: {
                                                                                                                                                                                                                                                          threadDumpAll: number;
                                                                                                                                                                                                                                                          threadDumpRunnable: number;
                                                                                                                                                                                                                                                          threadDumpTimedWaiting: number;
                                                                                                                                                                                                                                                          threadDumpWaiting: number;
                                                                                                                                                                                                                                                          threadDumpBlocked: number;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method ngOnInit

                                                                                                                                                                                                                                                            ngOnInit: () => void;

                                                                                                                                                                                                                                                              method open

                                                                                                                                                                                                                                                              open: () => void;

                                                                                                                                                                                                                                                                class ɵf

                                                                                                                                                                                                                                                                class JhiMetricsHttpRequestComponent {}

                                                                                                                                                                                                                                                                  property requestMetrics

                                                                                                                                                                                                                                                                  requestMetrics: {};
                                                                                                                                                                                                                                                                  • object containing http request related metrics

                                                                                                                                                                                                                                                                  property updating

                                                                                                                                                                                                                                                                  updating: boolean;
                                                                                                                                                                                                                                                                  • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                  method filterNaN

                                                                                                                                                                                                                                                                  filterNaN: (input: any) => any;

                                                                                                                                                                                                                                                                    class ɵg

                                                                                                                                                                                                                                                                    class JhiMetricsEndpointsRequestsComponent {}

                                                                                                                                                                                                                                                                      property endpointsRequestsMetrics

                                                                                                                                                                                                                                                                      endpointsRequestsMetrics: {};
                                                                                                                                                                                                                                                                      • object containing service related metrics

                                                                                                                                                                                                                                                                      property updating

                                                                                                                                                                                                                                                                      updating: boolean;
                                                                                                                                                                                                                                                                      • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                      class ɵh

                                                                                                                                                                                                                                                                      class JhiMetricsCacheComponent {}

                                                                                                                                                                                                                                                                        property cacheMetrics

                                                                                                                                                                                                                                                                        cacheMetrics: {};
                                                                                                                                                                                                                                                                        • object containing all cache related metrics

                                                                                                                                                                                                                                                                        property updating

                                                                                                                                                                                                                                                                        updating: boolean;
                                                                                                                                                                                                                                                                        • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                        method filterNaN

                                                                                                                                                                                                                                                                        filterNaN: (input: any) => any;

                                                                                                                                                                                                                                                                          class ɵi

                                                                                                                                                                                                                                                                          class JhiMetricsDatasourceComponent {}

                                                                                                                                                                                                                                                                            property datasourceMetrics

                                                                                                                                                                                                                                                                            datasourceMetrics: {
                                                                                                                                                                                                                                                                            active: any;
                                                                                                                                                                                                                                                                            min: any;
                                                                                                                                                                                                                                                                            idle: any;
                                                                                                                                                                                                                                                                            max: any;
                                                                                                                                                                                                                                                                            usage: any;
                                                                                                                                                                                                                                                                            acquire: any;
                                                                                                                                                                                                                                                                            creation: any;
                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                            • object containing all datasource related metrics

                                                                                                                                                                                                                                                                            property updating

                                                                                                                                                                                                                                                                            updating: boolean;
                                                                                                                                                                                                                                                                            • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                            method filterNaN

                                                                                                                                                                                                                                                                            filterNaN: (input: any) => any;

                                                                                                                                                                                                                                                                              class ɵj

                                                                                                                                                                                                                                                                              class JhiMetricsSystemComponent {}

                                                                                                                                                                                                                                                                                property systemMetrics

                                                                                                                                                                                                                                                                                systemMetrics: {};
                                                                                                                                                                                                                                                                                • object containing thread related metrics

                                                                                                                                                                                                                                                                                property updating

                                                                                                                                                                                                                                                                                updating: boolean;
                                                                                                                                                                                                                                                                                • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                                method convertMillisecondsToDuration

                                                                                                                                                                                                                                                                                convertMillisecondsToDuration: (ms: any) => string;

                                                                                                                                                                                                                                                                                  class ɵk

                                                                                                                                                                                                                                                                                  class JhiMetricsGarbageCollectorComponent {}

                                                                                                                                                                                                                                                                                    property garbageCollectorMetrics

                                                                                                                                                                                                                                                                                    garbageCollectorMetrics: any;
                                                                                                                                                                                                                                                                                    • object containing garbage collector related metrics

                                                                                                                                                                                                                                                                                    property updating

                                                                                                                                                                                                                                                                                    updating: boolean;
                                                                                                                                                                                                                                                                                    • boolean field saying if the metrics are in the process of being updated

                                                                                                                                                                                                                                                                                    class ɵl

                                                                                                                                                                                                                                                                                    class JhiThreadModalComponent implements OnInit {}

                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                      constructor(activeModal: any);

                                                                                                                                                                                                                                                                                        property activeModal

                                                                                                                                                                                                                                                                                        activeModal: any;

                                                                                                                                                                                                                                                                                          property threadDump

                                                                                                                                                                                                                                                                                          threadDump: any;

                                                                                                                                                                                                                                                                                            property threadDumpAll

                                                                                                                                                                                                                                                                                            threadDumpAll: number;

                                                                                                                                                                                                                                                                                              property threadDumpBlocked

                                                                                                                                                                                                                                                                                              threadDumpBlocked: number;

                                                                                                                                                                                                                                                                                                property threadDumpFilter

                                                                                                                                                                                                                                                                                                threadDumpFilter: any;

                                                                                                                                                                                                                                                                                                  property threadDumpRunnable

                                                                                                                                                                                                                                                                                                  threadDumpRunnable: number;

                                                                                                                                                                                                                                                                                                    property threadDumpTimedWaiting

                                                                                                                                                                                                                                                                                                    threadDumpTimedWaiting: number;

                                                                                                                                                                                                                                                                                                      property threadDumpWaiting

                                                                                                                                                                                                                                                                                                      threadDumpWaiting: number;

                                                                                                                                                                                                                                                                                                        method getBadgeClass

                                                                                                                                                                                                                                                                                                        getBadgeClass: (
                                                                                                                                                                                                                                                                                                        threadState: any
                                                                                                                                                                                                                                                                                                        ) => 'badge-success' | 'badge-info' | 'badge-warning' | 'badge-danger';

                                                                                                                                                                                                                                                                                                          method ngOnInit

                                                                                                                                                                                                                                                                                                          ngOnInit: () => void;

                                                                                                                                                                                                                                                                                                            Interfaces

                                                                                                                                                                                                                                                                                                            interface JhiAlert

                                                                                                                                                                                                                                                                                                            interface JhiAlert {}

                                                                                                                                                                                                                                                                                                              property close

                                                                                                                                                                                                                                                                                                              close?: (alerts: JhiAlert[]) => void;

                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                id?: number;

                                                                                                                                                                                                                                                                                                                  property msg

                                                                                                                                                                                                                                                                                                                  msg: string;

                                                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                                                    params?: any;

                                                                                                                                                                                                                                                                                                                      property position

                                                                                                                                                                                                                                                                                                                      position?: string;

                                                                                                                                                                                                                                                                                                                        property scoped

                                                                                                                                                                                                                                                                                                                        scoped?: boolean;

                                                                                                                                                                                                                                                                                                                          property timeout

                                                                                                                                                                                                                                                                                                                          timeout?: number;

                                                                                                                                                                                                                                                                                                                            property toast

                                                                                                                                                                                                                                                                                                                            toast?: boolean;

                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                              type: JhiAlertType;

                                                                                                                                                                                                                                                                                                                                interface JhiFileLoadError

                                                                                                                                                                                                                                                                                                                                interface JhiFileLoadError {}

                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                  key: JhiFileLoadErrorType;

                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                      property params

                                                                                                                                                                                                                                                                                                                                      params?: any;

                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                        type JhiAlertType

                                                                                                                                                                                                                                                                                                                                        type JhiAlertType = 'success' | 'danger' | 'warning' | 'info';

                                                                                                                                                                                                                                                                                                                                          type JhiFileLoadErrorType

                                                                                                                                                                                                                                                                                                                                          type JhiFileLoadErrorType = 'not.image' | 'could.not.extract';

                                                                                                                                                                                                                                                                                                                                            Package Files (41)

                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (11)

                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ng-jhipster.

                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ng-jhipster)
                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/ng-jhipster"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>