ag-grid-community

  • Version 25.3.0
  • Published
  • 31 MB
  • No dependencies
  • MIT license

Install

npm i ag-grid-community
yarn add ag-grid-community
pnpm add ag-grid-community

Overview

Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable CsvExportModule

const CsvExportModule: Module;

    Functions

    function Autowired

    Autowired: (name?: string) => Function;

      function Bean

      Bean: (beanName: string) => Function;

        function defaultGroupComparator

        defaultGroupComparator: (
        valueA: any,
        valueB: any,
        nodeA: RowNode,
        nodeB: RowNode,
        accentedCompare?: boolean
        ) => number;

          function GridListener

          GridListener: (eventName: string) => Function;

            function GuiListener

            GuiListener: (ref: string, eventName: string) => Function;

              function initialiseAgGridWithAngular1

              initialiseAgGridWithAngular1: (angular: any) => void;

                function initialiseAgGridWithWebComponents

                initialiseAgGridWithWebComponents: () => void;

                  function Optional

                  Optional: (name?: string) => Function;

                    function PostConstruct

                    PostConstruct: (
                    target: Object,
                    methodName: string,
                    descriptor: TypedPropertyDescriptor<any>
                    ) => void;

                      function PreConstruct

                      PreConstruct: (
                      target: Object,
                      methodName: string,
                      descriptor: TypedPropertyDescriptor<any>
                      ) => void;

                        function PreDestroy

                        PreDestroy: (
                        target: Object,
                        methodName: string,
                        descriptor: TypedPropertyDescriptor<any>
                        ) => void;

                          function Qualifier

                          Qualifier: (name: string) => Function;

                            function QuerySelector

                            QuerySelector: (selector?: string) => Function;

                              function RefSelector

                              RefSelector: (ref: string) => Function;

                                function simpleHttpRequest

                                simpleHttpRequest: (params: SimpleHttpRequestParams) => AgPromise<any>;

                                  function stringToArray

                                  stringToArray: (strData: string, delimiter?: string) => string[][];

                                    Classes

                                    class AgAbstractField

                                    abstract class AgAbstractField<
                                    TValue,
                                    TConfig extends IAgLabel = IAgLabel
                                    > extends AgAbstractLabel<TConfig> {}

                                      constructor

                                      constructor(config?: IAgLabel, template?: string, className?: string);

                                        property className

                                        protected readonly className?: string;

                                          property disabled

                                          protected disabled: boolean;

                                            property EVENT_CHANGED

                                            static EVENT_CHANGED: string;

                                              property previousValue

                                              protected previousValue: {};

                                                property value

                                                protected value: {};

                                                  method getPreviousValue

                                                  getPreviousValue: () => TValue | null | undefined;

                                                    method getValue

                                                    getValue: () => TValue | null | undefined;

                                                      method getWidth

                                                      getWidth: () => number;

                                                        method isDisabled

                                                        isDisabled: () => boolean;

                                                          method onValueChange

                                                          onValueChange: (callbackFn: (newValue?: TValue | null) => void) => this;

                                                            method postConstruct

                                                            protected postConstruct: () => void;

                                                              method setDisabled

                                                              setDisabled: (disabled: boolean) => this;

                                                                method setValue

                                                                setValue: (value?: TValue | null, silent?: boolean) => this;

                                                                  method setWidth

                                                                  setWidth: (width: number) => this;

                                                                    class AgAngleSelect

                                                                    class AgAngleSelect extends AgAbstractLabel {}

                                                                      constructor

                                                                      constructor(config?: IAgLabel);

                                                                        property dragService

                                                                        protected readonly dragService: DragService;

                                                                          property eLabel

                                                                          protected readonly eLabel: HTMLElement;

                                                                            method destroy

                                                                            protected destroy: () => void;

                                                                              method getRadius

                                                                              getRadius: () => number;

                                                                                method getValue

                                                                                getValue: (radians?: boolean) => number;

                                                                                  method onValueChange

                                                                                  onValueChange: (callbackFn: (newValue: number) => void) => this;

                                                                                    method postConstruct

                                                                                    postConstruct: () => void;

                                                                                      method setRadius

                                                                                      setRadius: (r: number) => this;

                                                                                        method setValue

                                                                                        setValue: (degrees: number, radians?: boolean) => this;

                                                                                          method setWidth

                                                                                          setWidth: (width: number) => this;

                                                                                            class AgCheckbox

                                                                                            class AgCheckbox extends AgAbstractInputField<HTMLInputElement, boolean> {}

                                                                                              constructor

                                                                                              constructor(config?: IInputField, className?: string, inputType?: string);

                                                                                                property labelAlignment

                                                                                                protected labelAlignment: LabelAlignment;

                                                                                                  method addInputListeners

                                                                                                  protected addInputListeners: () => void;

                                                                                                    method getNextValue

                                                                                                    getNextValue: () => boolean;

                                                                                                      method getValue

                                                                                                      getValue: () => boolean | undefined;

                                                                                                        method isReadOnly

                                                                                                        isReadOnly: ()