@types/angular

index signature

[requestType: string]: string | ((config: IRequestConfig) => string);

method disableAutoScrolling

disableAutoScrolling: () => void;

property yOffset

yOffset: any;

call signature

(): void;

call signature

(hash: string): void;

property strictDi

strictDi?: boolean | undefined;

property currentScope

currentScope: IScope;

• the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.

property defaultPrevented

defaultPrevented: boolean;

• true if preventDefault was called.

property name

name: string;

• name of the event.

property targetScope

targetScope: IScope;

• the scope on which the event was $emit-ed or $broadcast-ed.

method preventDefault

preventDefault: () => void;

• calling preventDefault sets defaultPrevented flag to true.

method stopPropagation

stopPropagation: () => void;

• calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed).

property element

element: JQueryStatic;

• Wraps a raw DOM element or HTML string as a jQuery element.

  If jQuery is available, angular.element is an alias for the jQuery function. If jQuery is not available, angular.element delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."

property version

version: {
    full: string;
    major: number;
    minor: number;
    dot: number;
    codeName: string;
};

method bind

bind: (context: any, fn: Function, ...args: any[]) => Function;

method bootstrap

bootstrap: (
    element: string | Element | JQuery | Document,
    modules?: Array<string | Function | any[]>,
    config?: IAngularBootstrapConfig
) => auto.IInjectorService;

• Use this function to manually start up angular application.

  Parameter element

  DOM element which is the root of angular application.

  Parameter modules

  An array of modules to load into the application. Each item in the array should be the name of a predefined module or a (DI annotated) function that will be invoked by the injector as a config block.

  Parameter config

  an object for defining configuration options for the application. The following keys are supported: - strictDi: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.

method copy

copy: <T>(source: T, destination?: T) => T;

• Creates a deep copy of source, which should be an object or an array.

  - If no destination is supplied, a copy of the object or array is created. - If a destination is provided, all of its elements (for array) or properties (for objects) are deleted and then all elements/properties from the source are copied to it. - If source is not an object or array (inc. null and undefined), source is returned. - If source is identical to 'destination' an exception will be thrown.

  Parameter source

  The source that will be used to make a copy. Can be any type, including primitives, null, and undefined.

  Parameter destination

  Destination into which the source is copied. If provided, must be of the same type as source.

method equals

equals: (value1: any, value2: any) => boolean;

method errorHandlingConfig

errorHandlingConfig: {
    (): IErrorHandlingConfig;
    (config: IErrorHandlingConfig): void;
};

• Configure several aspects of error handling in AngularJS if used as a setter or return the current configuration if used as a getter

method extend

extend: (destination: any, ...sources: any[]) => any;

method forEach

forEach: {
    <T, U extends ArrayLike<T> = T[]>(
        obj: U,
        iterator: (value: U[number], key: number, obj: U) => void,
        context?: any
    ): U;
    <T>(
        obj: { [index: string]: T },
        iterator: (value: T, key: string, obj: { [index: string]: T }) => void,
        context?: any
    ): { [index: string]: T };
    (
        obj: any,
        iterator: (value: any, key: any, obj: any) => void,
        context?: any
    ): any;
};

• Invokes the iterator function once for each item in obj collection, which can be either an object or an array. The iterator function is invoked with iterator(value, key), where value is the value of an object property or an array element and key is the object property key or array element index. Specifying a context for the function is optional.

  It is worth noting that .forEach does not iterate over inherited properties because it filters using the hasOwnProperty method.

  Parameter obj

  Object to iterate over.

  Parameter iterator

  Iterator function.

  Parameter context

  Object to become context (this) for the iterator function.

method fromJson

fromJson: (json: string) => any;

method identity

identity: <T>(arg?: T) => T;

method injector

injector: (modules?: any[], strictDi?: boolean) => auto.IInjectorService;

method isArray

isArray: (value: any) => value is any[];

method isDate

isDate: (value: any) => value is Date;

method isDefined

isDefined: (value: any) => boolean;

method isElement

isElement: (value: any) => boolean;

method isFunction

isFunction: (value: any) => value is Function;

method isNumber

isNumber: (value: any) => value is number;

method isObject

isObject: { (value: any): value is Object; <T>(value: any): value is T };

method isString

isString: (value: any) => value is string;

method isUndefined

isUndefined: (value: any) => boolean;

method merge

merge: (dst: any, ...src: any[]) => any;

• Deeply extends the destination object dst by copying own enumerable properties from the src object(s) to dst. You can specify multiple src objects. If you want to preserve original objects, you can do so by passing an empty object as the target: var object = angular.merge({}, object1, object2).

  Unlike extend(), merge() recursively descends into object properties of source objects, performing a deep copy.

  Parameter dst

  Destination object.

  Parameter src

  Source object(s).

method module

module: (
    name: string,
    requires?: string[],
    configFn?: Injectable<Function>
) => IModule;

• The angular.module is a global place for creating, registering and retrieving Angular modules. All modules (angular core or 3rd party) that should be available to an application must be registered using this mechanism.

  When passed two or more arguments, a new module is created. If passed only one argument, an existing module (the name passed as the first argument to module) is retrieved.

  Parameter name

  The name of the module to create or retrieve.

  Parameter requires

  The names of modules this module depends on. If specified then new module is being created. If unspecified then the module is being retrieved for further configuration.

  Parameter configFn

  Optional configuration function for the module.

method noop

noop: (...args: any[]) => void;

method reloadWithDebugInfo

reloadWithDebugInfo: () => void;

method resumeBootstrap

resumeBootstrap: (extraModules?: string[]) => ng.auto.IInjectorService;

• If window.name contains prefix NG_DEFER_BOOTSTRAP! when angular.bootstrap is called, the bootstrap process will be paused until angular.resumeBootstrap() is called.

  Parameter extraModules

  An optional array of modules that should be added to the original list of modules that the app was about to be bootstrapped with.

method toJson

toJson: (obj: any, pretty?: boolean | number) => string;

method UNSAFE_restoreLegacyJqLiteXHTMLReplacement

UNSAFE_restoreLegacyJqLiteXHTMLReplacement: () => void;

• Restores the pre-1.8 behavior of jqLite that turns XHTML-like strings like <div /><span /> to <div></div><span></span> instead of <div><span></span></div>. The new behavior is a security fix so if you use this method, please try to adjust to the change & remove the call as soon as possible. Note that this only patches jqLite. If you use jQuery 3.5.0 or newer, please read [jQuery 3.5 upgrade guide](https://jquery.com/upgrade-guide/3.5/) for more details about the workarounds.

index signature

[index: string]: (modelValue: any, viewValue: any) => IPromise<any>;

property $attr

$attr: Object;

• A map of DOM element attribute names to the normalized name. This is needed to do reverse lookup from normalized name back to actual name.

method $addClass

$addClass: (classVal: string) => void;

• Adds the CSS class value specified by the classVal parameter to the element. If animations are enabled then an animation will be triggered for the class addition.

method $normalize

$normalize: (name: string) => string;

• Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with x- or data-) to its normalized, camelCase form.

  Also there is special case for Moz prefix starting with upper case letter.

  For further information check out the guide on

  See Also

  • https://docs.angularjs.org/guide/directive#matching-directives

method $observe

$observe: <T>(name: string, fn: (value?: T) => any) => Function;

• Observes an interpolated attribute. The observer function will be invoked once during the next $digest following compilation. The observer is then invoked whenever the interpolated value changes.

method $removeClass

$removeClass: (classVal: string) => void;

• Removes the CSS class value specified by the classVal parameter from the element. If animations are enabled then an animation will be triggered for the class removal.

method $set

$set: (key: string, value: any) => void;

• Set DOM element attribute value.

method $updateClass

$updateClass: (newClasses: string, oldClasses: string) => void;

• Adds and removes the appropriate CSS class values to the element based on the difference between the new and old CSS class values (specified as newClasses and oldClasses).

index signature

[name: string]: any;

• this is necessary to be able to access the scoped attributes. it's not very elegant because you have to use attrs['foo'] instead of attrs.foo but I don't know of a better way this should really be limited to return string but it creates this problem: http://stackoverflow.com/q/17201854/165656

method get

get: (cacheId: string) => ICacheObject;

• Get access to a cache object by the cacheId used when it was created.

  Parameter cacheId

  Name or id of a cache to access.

method info

info: () => any;

• Get information about all the caches that have been created.

  Returns

  key-value map of cacheId to the result of calling cache#info

call signature

(cacheId: string, optionsMap?: { capacity?: number | undefined }): ICacheObject;

• Factory that constructs Cache objects and gives access to them.

  Parameter cacheId

  Name or id of the newly created cache.

  Parameter optionsMap

  Options object that specifies the cache behavior. Properties:

  capacity — turns the cache into LRU cache.

method destroy

destroy: () => void;

• Destroys the Cache object entirely, removing it from the $cacheFactory set.

method get

get: <T>(key: string) => T | undefined;

• Retrieves named data stored in the Cache object.

  Parameter key

  the key of the data to be retrieved

method info

info: () => { id: string; size: number };

• Retrieve information regarding a particular Cache.

method put

put: <T>(key: string, value?: T) => T;

• Inserts a named entry into the Cache object to be retrieved later, and incrementing the size of the cache if the key was not already present in the cache. If behaving like an LRU cache, it will also remove stale entries from the set.

  It will not insert undefined values into the cache.

  Parameter key

  the key under which the cached data is stored.

  Parameter value

  the value to store alongside the key. If it is undefined, the key will not be stored.

method remove

remove: (key: string) => void;

• Removes an entry from the Cache object.

  Parameter key

  the key of the entry to be removed

method removeAll

removeAll: () => void;

• Clears the cache object of any entries.

property currentValue

currentValue: T;

property previousValue

previousValue: T;

method isFirstChange

isFirstChange: () => boolean;

call signature

(clonedElement?: JQLite, scope?: IScope): any;

property constant

constant: boolean;

property literal

literal: boolean;

method assign

assign: (context: any, value: any) => any;

call signature

(context: any, locals?: any): any;

method aHrefSanitizationTrustedUrlList

aHrefSanitizationTrustedUrlList: {
    (): RegExp;
    (regexp: RegExp): ICompileProvider;
};

method aHrefSanitizationWhitelist

aHrefSanitizationWhitelist: { (): RegExp; (regexp: RegExp): ICompileProvider };

• Deprecated

  The old name of aHrefSanitizationTrustedUrlList. Kept for compatibility.

method commentDirectivesEnabled

commentDirectivesEnabled: { (): boolean; (enabled: boolean): ICompileProvider };

• It indicates to the compiler whether or not directives on comments should be compiled. It results in a compilation performance gain since the compiler doesn't have to check comments when looking for directives. Defaults to true. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#commentDirectivesEnabled

method component

component: {
    (name: string, options: IComponentOptions): ICompileProvider;
    (object: { [componentName: string]: IComponentOptions }): ICompileProvider;
};

method cssClassDirectivesEnabled

cssClassDirectivesEnabled: { (): boolean; (enabled: boolean): ICompileProvider };

• It indicates to the compiler whether or not directives on element classes should be compiled. It results in a compilation performance gain since the compiler doesn't have to check element classes when looking for directives. Defaults to true. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#cssClassDirectivesEnabled

method debugInfoEnabled

debugInfoEnabled: { (): boolean; (enabled: boolean): ICompileProvider };

method directive

directive: {
    <
        TScope extends IScope = IScope,
        TElement extends JQLite = JQLite,
        TAttributes extends IAttributes = IAttributes,
        TController extends IDirectiveController = IController
    >(
        name: string,
        directiveFactory: Injectable<
            IDirectiveFactory<TScope, TElement, TAttributes, TController>
        >
    ): ICompileProvider;
    <
        TScope extends IScope = IScope,
        TElement extends JQLite = JQLite,
        TAttributes extends IAttributes = IAttributes,
        TController extends IDirectiveController = IController
    >(object: {
        [directiveName: string]: Injectable<
            IDirectiveFactory<TScope, TElement, TAttributes, TController>
        >;
    }): ICompileProvider;
};

method imgSrcSanitizationTrustedUrlList

imgSrcSanitizationTrustedUrlList: {
    (): RegExp;
    (regexp: RegExp): ICompileProvider;
};

method imgSrcSanitizationWhitelist

imgSrcSanitizationWhitelist: { (): RegExp; (regexp: RegExp): ICompileProvider };

• Deprecated

  The old name of imgSrcSanitizationTrustedUrlList. Kept for compatibility.

method onChangesTtl

onChangesTtl: { (): number; (limit: number): ICompileProvider };

• Sets the number of times $onChanges hooks can trigger new changes before giving up and assuming that the model is unstable. Increasing the TTL could have performance implications, so you should not change it without proper justification. Default: 10. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#onChangesTtl

method strictComponentBindingsEnabled

strictComponentBindingsEnabled: {
    (): boolean;
    (enabled: boolean): ICompileProvider;
};

• Call this method to enable/disable strict component bindings check. If enabled, the compiler will enforce that for all bindings of a component that are not set as optional with ?, an attribute needs to be provided on the component's HTML tag. Defaults to false. See: https://docs.angularjs.org/api/ng/provider/$compileProvider#strictComponentBindingsEnabled

call signature

(
    element: string | Element | JQuery,
    transclude?: ITranscludeFunction,
    maxPriority?: number
): ITemplateLinkingFunction;

property bindings

bindings?: { [boundProperty: string]: string } | undefined;

• Define DOM attribute binding to component properties. Component properties are always bound to the component controller and not to the scope.

property controller

controller?: string | Injectable<IControllerConstructor> | undefined;

• Controller constructor function that should be associated with newly created scope or the name of a registered controller if passed as a string. Empty function by default. Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

property controllerAs

controllerAs?: string | undefined;

• An identifier name for a reference to the controller. If present, the controller will be published to its scope under the specified name. If not present, this will default to '$ctrl'.

property require

require?: { [controller: string]: string } | undefined;

• Requires the controllers of other directives and binds them to this component's controller. The object keys specify the property names under which the required controllers (object values) will be bound. Note that the required controllers will not be available during the instantiation of the controller, but they are guaranteed to be available just before the $onInit method is executed!

property template

template?: string | Injectable<(...args: any[]) => string> | undefined;

• html template as a string or a function that returns an html template as a string which should be used as the contents of this component. Empty string by default. If template is a function, then it is injected with the following locals: $element - Current element $attrs - Current attributes object for the element Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

property templateUrl

templateUrl?: string | Injectable<(...args: any[]) => string> | undefined;

• Path or function that returns a path to an html template that should be used as the contents of this component. If templateUrl is a function, then it is injected with the following locals: $element - Current element $attrs - Current attributes object for the element Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)

property transclude

transclude?: boolean | { [slot: string]: string } | undefined;

• Whether transclusion is enabled. Disabled by default.

method $doCheck

$doCheck: () => void;

• Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes. Any actions that you wish to take in response to the changes that you detect must be invoked from this hook; implementing this has no effect on when $onChanges is called. For example, this hook could be useful if you wish to perform a deep equality check, or to check a Date object, changes to which would not be detected by Angular's change detector and thus not trigger $onChanges. This hook is invoked with no arguments; if detecting changes, you must store the previous value(s) for comparison to the current values.

method $onChanges

$onChanges: (onChangesObj: IOnChangesObject) => void;

• Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound properties that have changed, and the values are an IChangesObject object of the form { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as cloning the bound value to prevent accidental mutation of the outer value.

method $onDestroy

$onDestroy: () => void;

• Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources, watches and event handlers.

method $onInit

$onInit: () => void;

• Called on each controller after all the controllers on an element have been constructed and had their bindings initialized (and before the pre & post linking functions for the directives on this element). This is a good place to put initialization code for your controller.

method $postLink

$postLink: () => void;

• Called after this controller's element and its children have been linked. Similar to the post-link function this hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain templateUrl directives will not have been compiled and linked since they are waiting for their template to load asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather different in Angular 1 there is no direct mapping and care should be taken when upgrading.

index signature

[s: string]: any;

property $element

$element: JQuery;

property $scope

$scope: ng.IScope;

method register

register: {
    (name: string, controllerConstructor: Function): void;
    (name: string, dependencyAnnotatedConstructor: any[]): void;
};

call signature

<T>(controllerConstructor: new (...args: any[]) => T, locals?: any): T;

call signature

<T>(controllerConstructor: (...args: any[]) => T, locals?: any): T;

call signature

<T>(controllerName: string, locals?: any): T;

property promise

promise: IPromise<T>;

method notify

notify: (state?: any) => void;

method reject

reject: (reason?: any) => void;

method resolve

resolve: (value?: T | IPromise<T>) => void;

property bindToController

bindToController?: boolean | { [boundProperty: string]: string } | undefined;

• Deprecation warning: although bindings for non-ES6 class controllers are currently bound to this before the controller constructor is called, this use is now deprecated. Please place initialization code that relies upon bindings inside a $onInit method on the controller, instead.

property compile

compile?:
    | IDirectiveCompileFn<TScope, TElement, TAttributes, TController>
    | undefined;

property controller

controller?: string | Injectable<IControllerConstructor> | undefined;

property controllerAs

controllerAs?: string | undefined;

property link

link?:
    | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
    | IDirectivePrePost<TScope, TElement, TAttributes, TController>
    | undefined;

property multiElement

multiElement?: boolean | undefined;

property priority

priority?: number | undefined;

property replace

replace?: boolean | undefined;

• Deprecated

property require

require?: string | string[] | { [controller: string]: string } | undefined;

property restrict

restrict?: string | undefined;

property scope

scope?: boolean | { [boundProperty: string]: string } | undefined;

property template

template?:
    | string
    | ((tElement: TElement, tAttrs: TAttributes) => string)
    | undefined;

property templateNamespace

templateNamespace?: string | undefined;

property templateUrl

templateUrl?:
    | string
    | ((tElement: TElement, tAttrs: TAttributes) => string)
    | undefined;

property terminal

terminal?: boolean | undefined;

property transclude

transclude?: boolean | 'element' | { [slot: string]: string } | undefined;

call signature

(
    templateElement: TElement,
    templateAttributes: TAttributes,
    /**
     * @deprecated
     * Note: The transclude function that is passed to the compile function is deprecated,
     * as it e.g. does not know about the right outer scope. Please use the transclude function
     * that is passed to the link function instead.
     */
    transclude: ITranscludeFunction
):
    | void
    | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>
    | IDirectivePrePost<TScope, TElement, TAttributes, TController>;

call signature

(...args: any[]):
    | IDirective<TScope, TElement, TAttributes, TController>
    | IDirectiveLinkFn<TScope, TElement, TAttributes, TController>;

call signature

(
    scope: TScope,
    instanceElement: TElement,
    instanceAttributes: TAttributes,
    controller?: TController,
    transclude?: ITranscludeFunction
): void;

property post

post?: IDirectiveLinkFn<TScope, TElement, TAttributes, TController> | undefined;

property pre

pre?: IDirectiveLinkFn<TScope, TElement, TAttributes, TController> | undefined;

method $doCheck

$doCheck: () => void;

• Called on each turn of the digest cycle. Provides an opportunity to detect and act on changes. Any actions that you wish to take in response to the changes that you detect must be invoked from this hook; implementing this has no effect on when $onChanges is called. For example, this hook could be useful if you wish to perform a deep equality check, or to check a Date object, changes to which would not be detected by Angular's change detector and thus not trigger $onChanges. This hook is invoked with no arguments; if detecting changes, you must store the previous value(s) for comparison to the current values.

index signature

[index: number]: HTMLElement & Document;

property objectMaxDepth

objectMaxDepth?: number | undefined;

• The max depth for stringifying objects. Setting to a non-positive or non-numeric value, removes the max depth limit 5

property urlErrorParamsEnabled

urlErrorParamsEnabled?: boolean | undefined;

• Specifies whether the generated error url will contain the parameters of the thrown error. Disabling the parameters can be useful if the generated error url is very long. true;

call signature

(exception: Error, cause?: string): void;

call signature

(amount: number, symbol?: string, fractionSize?: number): string;

• Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default symbol for current locale is used.

  Parameter amount

  Input to filter.

  Parameter symbol

  Currency symbol or identifier to be displayed.

  Parameter fractionSize

  Number of decimal places to round the amount to, defaults to default max fraction size for current locale Formatted number

call signature

(date: Date | number | string, format?: string, timezone?: string): string;

• Formats date to a string based on the requested format.

  Parameter date

  Date to format either as Date object, milliseconds (string or number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.sssZ and its shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is specified in the string input, the time is considered to be in the local timezone.

  Parameter format

  Formatting rules (see Description). If not specified, mediumDate is used.

  Parameter timezone

  Timezone to be used for formatting. It understands UTC/GMT and the continental US time zone abbreviations, but for general use, use a time zone offset, for example, '+0430' (4 hours, 30 minutes east of the Greenwich meridian) If not specified, the timezone of the browser will be used. Formatted string or the input if input is not recognized as date/millis.

call signature

<T>(
    array: T[],
    expression:
        | string
        | IFilterFilterPatternObject
        | IFilterFilterPredicateFunc<T>,
    comparator?: IFilterFilterComparatorFunc<T> | boolean
): T[];

call signature

(actual: T, expected: T): boolean;

index signature

[name: string]: any;

call signature

(value: T, index: number, array: T[]): boolean;

property $stateful

$stateful?: boolean | undefined;

• By default, filters are only run once the input value changes. By marking the filter as $stateful, the filter will be run on every $digest to update the output. **This is strongly discouraged.** See https://docs.angularjs.org/guide/filter#stateful-filters

call signature

(object: any, spacing?: number): string;

• Allows you to convert a JavaScript object into JSON string.

  Parameter object

  Any JavaScript object (including arrays and primitive types) to filter.

  Parameter spacing

  The number of spaces to use per indentation, defaults to 2. JSON string.

call signature

<T>(input: T[], limit: string | number, begin?: string | number): T[];

• Creates a new array containing only a specified number of elements. The elements are taken from either the beginning or the end of the source array, string or number, as specified by the value and sign (positive or negative) of limit.

  Parameter input

  Source array to be limited.

  Parameter limit

  The length of the returned array. If the limit number is positive, limit number of items from the beginning of the source array/string are copied. If the number is negative, limit number of items from the end of the source array are copied. The limit will be trimmed if it exceeds array.length. If limit is undefined, the input will be returned unchanged.

  Parameter begin

  Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0. A new sub-array of length limit or less if input array had less than limit elements.

call signature

(
    input: string | number,
    limit: string | number,
    begin?: string | number
): string;

• Creates a new string containing only a specified number of elements. The elements are taken from either the beginning or the end of the source string or number, as specified by the value and sign (positive or negative) of limit. If a number is used as input, it is converted to a string.

  Parameter input

  Source string or number to be limited.

  Parameter limit

  The length of the returned string. If the limit number is positive, limit number of items from the beginning of the source string are copied. If the number is negative, limit number of items from the end of the source string are copied. The limit will be trimmed if it exceeds input.length. If limit is undefined, the input will be returned unchanged.

  Parameter begin

  Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0. A new substring of length limit or less if input had less than limit elements.

call signature

(value: string): string;

• Converts string to lowercase.

call signature

(value: number | string, fractionSize?: number | string): string;

• Formats a number as text.

  Parameter number

  Number to format.

  Parameter fractionSize

  Number of decimal places to round the number to. If this is not provided then the fraction size is computed from the current locale's number formatting pattern. In the case of the default locale, it will be 3. Number rounded to decimalPlaces and places a “,” after each third digit.

call signature

<T>(
    array: T[],
    expression:
        | string
        | ((value: T) => any)
        | Array<((value: T) => any) | string>,
    reverse?: boolean,
    comparator?: IFilterOrderByComparatorFunc
): T[];

• Orders a specified array by the expression predicate. It is ordered alphabetically for strings and numerically for numbers. Note: if you notice numbers are not being sorted as expected, make sure they are actually being saved as numbers and not strings.

  Parameter array

  The array to sort.

  Parameter expression

  A predicate to be used by the comparator to determine the order of elements.

  Parameter reverse

  Reverse the order of the array.

  Parameter comparator

  Function used to determine the relative order of value pairs. An array containing the items from the specified collection, ordered by a comparator function based on the values computed using the expression predicate.