@angular/platform-browser

  • Version 16.2.6
  • Published
  • 780 kB
  • 1 dependency
  • MIT license

Install

npm i @angular/platform-browser
yarn add @angular/platform-browser
pnpm add @angular/platform-browser

Overview

Angular - library for using Angular in a web browser

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable EVENT_MANAGER_PLUGINS

const EVENT_MANAGER_PLUGINS: InjectionToken<EventManagerPlugin[]>;
  • The injection token for the event-manager plug-in service.

variable HAMMER_GESTURE_CONFIG

const HAMMER_GESTURE_CONFIG: InjectionToken<HammerGestureConfig>;
  • DI token for providing [HammerJS](https://hammerjs.github.io/) support to Angular.

    See Also

variable HAMMER_LOADER

const HAMMER_LOADER: InjectionToken<HammerLoader>;

variable makeStateKey

const makeStateKey: any;
  • Create a StateKey<T> that can be used to store value of type T with TransferState.

    Example:

    const COUNTER_KEY = makeStateKey<number>('counter');
    let value = 10;
    transferState.set(COUNTER_KEY, value);

    Deprecated

    makeStateKey has moved, please import makeStateKey from @angular/core instead.

variable ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS

const ɵINTERNAL_BROWSER_PLATFORM_PROVIDERS: StaticProvider[];

    variable REMOVE_STYLES_ON_COMPONENT_DESTROY

    const REMOVE_STYLES_ON_COMPONENT_DESTROY: InjectionToken<boolean>;
    • A [DI token](guide/glossary#di-token "DI token definition") that indicates whether styles of destroyed components should be removed from DOM.

      By default, the value is set to false. This will be changed in the next major version.

    variable TransferState

    const TransferState: new () => TransferState_2;

      variable VERSION

      const VERSION: Version;

      Functions

      function bootstrapApplication

      bootstrapApplication: (
      rootComponent: Type<unknown>,
      options?: ApplicationConfig_2
      ) => Promise<ApplicationRef>;
      • Bootstraps an instance of an Angular application and renders a standalone component as the application's root component. More information about standalone components can be found in [this guide](guide/standalone-components).

        The root component passed into this function *must* be a standalone one (should have the standalone: true flag in the @Component decorator config).

        @Component({
        standalone: true,
        template: 'Hello world!'
        })
        class RootComponent {}
        const appRef: ApplicationRef = await bootstrapApplication(RootComponent);

        You can add the list of providers that should be available in the application injector by specifying the providers field in an object passed as the second argument:

        await bootstrapApplication(RootComponent, {
        providers: [
        {provide: BACKEND_URL, useValue: 'https://yourdomain.com/api'}
        ]
        });

        The importProvidersFrom helper method can be used to collect all providers from any existing NgModule (and transitively from all NgModules that it imports):

        await bootstrapApplication(RootComponent, {
        providers: [
        importProvidersFrom(SomeNgModule)
        ]
        });

        Note: the bootstrapApplication method doesn't include [Testability](api/core/Testability) by default. You can add [Testability](api/core/Testability) by getting the list of necessary providers using provideProtractorTestingSupport() function and adding them into the providers array, for example:

        import {provideProtractorTestingSupport} from '@angular/platform-browser';
        await bootstrapApplication(RootComponent, {providers: [provideProtractorTestingSupport()]});

        Parameter rootComponent

        A reference to a standalone component that should be rendered.

        Parameter options

        Extra configuration for the bootstrap operation, see ApplicationConfig for additional info.

        Returns

        A promise that returns an ApplicationRef instance once resolved.

      function createApplication

      createApplication: (options?: ApplicationConfig_2) => Promise<ApplicationRef>;
      • Create an instance of an Angular application without bootstrapping any components. This is useful for the situation where one wants to decouple application environment creation (a platform and associated injectors) from rendering components on a screen. Components can be subsequently bootstrapped on the returned ApplicationRef.

        Parameter options

        Extra configuration for the application environment, see ApplicationConfig for additional info.

        Returns

        A promise that returns an ApplicationRef instance once resolved.

      function disableDebugTools

      disableDebugTools: () => void;
      • Disables Angular tools.

      function enableDebugTools

      enableDebugTools: <T>(ref: ComponentRef<T>) => ComponentRef<T>;
      • Enabled Angular debug tools that are accessible via your browser's developer console.

        Usage:

        1. Open developer console (e.g. in Chrome Ctrl + Shift + j) 1. Type ng. (usually the console will show auto-complete suggestion) 1. Try the change detection profiler ng.profiler.timeChangeDetection() then hit Enter.

      function ɵinitDomAdapter

      ɵinitDomAdapter: () => void;

        function platformBrowser

        platformBrowser: (extraProviders?: StaticProvider[]) => PlatformRef;
        • A factory function that returns a PlatformRef instance associated with browser service providers.

        function provideClientHydration

        provideClientHydration: (
        ...features: HydrationFeature<HydrationFeatureKind>[]
        ) => EnvironmentProviders;
        • Sets up providers necessary to enable hydration functionality for the application.

          By default, the function enables the recommended set of features for the optimal performance for most of the applications. You can enable/disable features by passing special functions (from the HydrationFeatures set) as arguments to the provideClientHydration function. It includes the following features:

          * Reconciling DOM hydration. Learn more about it [here](guide/hydration). * [HttpClient](api/common/http/HttpClient) response caching while running on the server and transferring this cache to the client to avoid extra HTTP requests. Learn more about data caching [here](/guide/universal#caching-data-when-using-httpclient).

          These functions functions will allow you to disable some of the default features: * withNoDomReuse to disable DOM nodes reuse during hydration * withNoHttpTransferCache to disable HTTP transfer cache

          Basic example of how you can enable hydration in your application when bootstrapApplication function is used:

          bootstrapApplication(AppComponent, {
          providers: [provideClientHydration()]
          });

          Alternatively if you are using NgModules, you would add provideClientHydration to your root app module's provider list.

          @NgModule({
          declarations: [RootCmp],
          bootstrap: [RootCmp],
          providers: [provideClientHydration()],
          })
          export class AppModule {}

          Parameter features

          Optional features to configure additional router behaviors.

          Returns

          A set of providers to enable hydration.

          See Also

        function provideProtractorTestingSupport

        provideProtractorTestingSupport: () => Provider[];
        • Returns a set of providers required to setup [Testability](api/core/Testability) for an application bootstrapped using the bootstrapApplication function. The set of providers is needed to support testing an application with Protractor (which relies on the Testability APIs to be present).

          Returns

          An array of providers required to setup Testability for an application and make it available for testing using Protractor.

        function withNoDomReuse

        withNoDomReuse: () => HydrationFeature<HydrationFeatureKind.NoDomReuseFeature>;
        • Disables DOM nodes reuse during hydration. Effectively makes Angular re-render an application from scratch on the client.

          When this option is enabled, make sure that the initial navigation option is configured for the Router as enabledBlocking by using the withEnabledBlockingInitialNavigation in the provideRouter call:

          bootstrapApplication(RootComponent, {
          providers: [
          provideRouter(
          // ... other features ...
          withEnabledBlockingInitialNavigation()
          ),
          provideClientHydration(withNoDomReuse())
          ]
          });

          This would ensure that the application is rerendered after all async operations in the Router (such as lazy-loading of components, waiting for async guards and resolvers) are completed to avoid clearing the DOM on the client too soon, thus causing content flicker.

          See Also

        function withNoHttpTransferCache

        withNoHttpTransferCache: () => HydrationFeature<HydrationFeatureKind.NoHttpTransferCache>;
        • Disables HTTP transfer cache. Effectively causes HTTP requests to be performed twice: once on the server and other one on the browser.

        Classes

        class BrowserModule

        class BrowserModule {}
        • Exports required infrastructure for all Angular apps. Included by default in all Angular apps created with the CLI new command. Re-exports CommonModule and ApplicationModule, making their exports and providers available to all apps.

        constructor

        constructor(providersAlreadyPresent: boolean);

          property ɵfac

          static ɵfac: i0.ɵɵFactoryDeclaration<
          BrowserModule,
          [{ optional: true; skipSelf: true }]
          >;

            property ɵinj

            static ɵinj: i0.ɵɵInjectorDeclaration<BrowserModule>;

              property ɵmod

              static ɵmod: i0.ɵɵNgModuleDeclaration<BrowserModule, never, never, [any, any]>;

                method withServerTransition

                static withServerTransition: (params: {
                appId: string;
                }) => ModuleWithProviders<BrowserModule>;
                • Configures a browser-based app to transition from a server-rendered app, if one is present on the page.

                  Parameter params

                  An object containing an identifier for the app to transition. The ID must match between the client and server versions of the app.

                  Returns

                  The reconfigured BrowserModule to import into the app's root AppModule.

                  Deprecated

                  Use APP_ID instead to set the application ID.

                class By

                class By {}

                method all

                static all: () => Predicate<DebugNode>;
                • Match all nodes.

                  ### Example

                method css

                static css: (selector: string) => Predicate<DebugElement>;
                • Match elements by the given CSS selector.

                  ### Example

                method directive

                static directive: (type: Type<any>) => Predicate<DebugNode>;
                • Match nodes that have the given directive present.

                  ### Example

                class DomSanitizer

                abstract class DomSanitizer implements Sanitizer {}
                • DomSanitizer helps preventing Cross Site Scripting Security bugs (XSS) by sanitizing values to be safe to use in the different DOM contexts.

                  For example, when binding a URL in an <a [href]="someValue"> hyperlink, someValue will be sanitized so that an attacker cannot inject e.g. a javascript: URL that would execute code on the website.

                  In specific situations, it might be necessary to disable sanitization, for example if the application genuinely needs to produce a javascript: style link with a dynamic value in it. Users can bypass security by constructing a value with one of the bypassSecurityTrust... methods, and then binding to that value from the template.

                  These situations should be very rare, and extraordinary care must be taken to avoid creating a Cross Site Scripting (XSS) security bug!

                  When using bypassSecurityTrust..., make sure to call the method as early as possible and as close as possible to the source of the value, to make it easy to verify no security bug is created by its use.

                  It is not required (and not recommended) to bypass security if the value is safe, e.g. a URL that does not start with a suspicious protocol, or an HTML snippet that does not contain dangerous code. The sanitizer leaves safe values intact.

                  Calling any of the bypassSecurityTrust... APIs disables Angular's built-in sanitization for the value passed in. Carefully check and audit all values and code paths going into this call. Make sure any user data is appropriately escaped for this security context. For more detail, see the [Security Guide](https://g.co/ng/security).

                property ɵfac

                static ɵfac: i0.ɵɵFactoryDeclaration<DomSanitizer, never>;

                  property ɵprov

                  static ɵprov: i0.ɵɵInjectableDeclaration<DomSanitizer>;

                    method bypassSecurityTrustHtml

                    abstract bypassSecurityTrustHtml: (value: string) => SafeHtml;
                    • Bypass security and trust the given value to be safe HTML. Only use this when the bound HTML is unsafe (e.g. contains <script> tags) and the code should be executed. The sanitizer will leave safe HTML intact, so in most situations this method should not be used.

                      **WARNING:** calling this method with untrusted user data exposes your application to XSS security risks!

                    method bypassSecurityTrustResourceUrl

                    abstract bypassSecurityTrustResourceUrl: (value: string) => SafeResourceUrl;
                    • Bypass security and trust the given value to be a safe resource URL, i.e. a location that may be used to load executable code from, like <script src>, or <iframe src>.

                      **WARNING:** calling this method with untrusted user data exposes your application to XSS security risks!

                    method bypassSecurityTrustScript

                    abstract bypassSecurityTrustScript: (value: string) => SafeScript;
                    • Bypass security and trust the given value to be safe JavaScript.

                      **WARNING:** calling this method with untrusted user data exposes your application to XSS security risks!

                    method bypassSecurityTrustStyle

                    abstract bypassSecurityTrustStyle: (value: string) => SafeStyle;
                    • Bypass security and trust the given value to be safe style value (CSS).

                      **WARNING:** calling this method with untrusted user data exposes your application to XSS security risks!

                    method bypassSecurityTrustUrl

                    abstract bypassSecurityTrustUrl: (value: string) => SafeUrl;
                    • Bypass security and trust the given value to be a safe style URL, i.e. a value that can be used in hyperlinks or <img src>.

                      **WARNING:** calling this method with untrusted user data exposes your application to XSS security risks!

                    method sanitize

                    abstract sanitize: (
                    context: SecurityContext,
                    value: SafeValue | string | null
                    ) => string | null;
                    • Gets a safe value from either a known safe value or a value with unknown safety.

                      If the given value is already a SafeValue, this method returns the unwrapped value. If the security context is HTML and the given value is a plain string, this method sanitizes the string, removing any potentially unsafe content. For any other security context, this method throws an error if provided with a plain string.

                    class EventManager

                    class EventManager {}
                    • An injectable service that provides event management for Angular through a browser plug-in.

                    constructor

                    constructor(plugins: EventManagerPlugin[], _zone: NgZone);
                    • Initializes an instance of the event-manager service.

                    property ɵfac

                    static ɵfac: i0.ɵɵFactoryDeclaration<EventManager, never>;

                      property ɵprov

                      static ɵprov: i0.ɵɵInjectableDeclaration<EventManager>;

                        method addEventListener

                        addEventListener: (
                        element: HTMLElement,
                        eventName: string,
                        handler: Function
                        ) => Function;
                        • Registers a handler for a specific element and event.

                          Parameter element

                          The HTML element to receive event notifications.

                          Parameter eventName

                          The name of the event to listen for.

                          Parameter handler

                          A function to call when the notification occurs. Receives the event object as an argument.

                          Returns

                          A callback function that can be used to remove the handler.

                        method getZone

                        getZone: () => NgZone;
                        • Retrieves the compilation zone in which event listeners are registered.

                        class HammerGestureConfig

                        class HammerGestureConfig {}
                        • An injectable [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager) for gesture recognition. Configures specific event recognition.

                        property events

                        events: string[];
                        • A set of supported event names for gestures to be used in Angular. Angular supports all built-in recognizers, as listed in [HammerJS documentation](https://hammerjs.github.io/).

                        property options

                        options?: {
                        cssProps?: any;
                        domEvents?: boolean;
                        enable?: boolean | ((manager: any) => boolean);
                        preset?: any[];
                        touchAction?: string;
                        recognizers?: any[];
                        inputClass?: any;
                        inputTarget?: EventTarget;
                        };
                        • Properties whose default values can be overridden for a given event. Different sets of properties apply to different events. For information about which properties are supported for which events, and their allowed and default values, see [HammerJS documentation](https://hammerjs.github.io/).

                        property overrides

                        overrides: { [key: string]: Object };
                        • Maps gesture event names to a set of configuration options that specify overrides to the default values for specific properties.

                          The key is a supported event name to be configured, and the options object contains a set of properties, with override values to be applied to the named recognizer event. For example, to disable recognition of the rotate event, specify {"rotate": {"enable": false}}.

                          Properties that are not present take the HammerJS default values. For information about which properties are supported for which events, and their allowed and default values, see [HammerJS documentation](https://hammerjs.github.io/).

                        property ɵfac

                        static ɵfac: i0.ɵɵFactoryDeclaration<HammerGestureConfig, never>;

                          property ɵprov

                          static ɵprov: i0.ɵɵInjectableDeclaration<HammerGestureConfig>;

                            method buildHammer

                            buildHammer: (element: HTMLElement) => HammerInstance;
                            • Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager) and attaches it to a given HTML element.

                              Parameter element

                              The element that will recognize gestures.

                              Returns

                              A HammerJS event-manager object.

                            class HammerModule

                            class HammerModule {}
                            • Adds support for HammerJS.

                              Import this module at the root of your application so that Angular can work with HammerJS to detect gesture events.

                              Note that applications still need to include the HammerJS script itself. This module simply sets up the coordination layer between HammerJS and Angular's EventManager.

                            property ɵfac

                            static ɵfac: i0.ɵɵFactoryDeclaration<HammerModule, never>;

                              property ɵinj

                              static ɵinj: i0.ɵɵInjectorDeclaration<HammerModule>;

                                property ɵmod

                                static ɵmod: i0.ɵɵNgModuleDeclaration<HammerModule, never, never, never>;

                                  class Meta

                                  class Meta {}
                                  • A service for managing HTML <meta> tags.

                                    Properties of the MetaDefinition object match the attributes of the HTML <meta> tag. These tags define document metadata that is important for things like configuring a Content Security Policy, defining browser compatibility and security settings, setting HTTP Headers, defining rich content for social sharing, and Search Engine Optimization (SEO).

                                    To identify specific <meta> tags in a document, use an attribute selection string in the format "tag_attribute='value string'". For example, an attrSelector value of "name='description'" matches a tag whose name attribute has the value "description". Selectors are used with the querySelector() Document method, in the format meta[{attrSelector}].

                                    See Also

                                    • [HTML meta tag](https://developer.mozilla.org/docs/Web/HTML/Element/meta)

                                    • [Document.querySelector()](https://developer.mozilla.org/docs/Web/API/Document/querySelector)

                                  constructor

                                  constructor(_doc: any);

                                    property ɵfac

                                    static ɵfac: i0.ɵɵFactoryDeclaration<Meta, never>;

                                      property ɵprov

                                      static ɵprov: i0.ɵɵInjectableDeclaration<Meta>;

                                        method addTag

                                        addTag: (tag: MetaDefinition, forceCreation?: boolean) => HTMLMetaElement | null;
                                        • Retrieves or creates a specific <meta> tag element in the current HTML document. In searching for an existing tag, Angular attempts to match the name or property attribute values in the provided tag definition, and verifies that all other attribute values are equal. If an existing element is found, it is returned and is not modified in any way.

                                          Parameter tag

                                          The definition of a <meta> element to match or create.

                                          Parameter forceCreation

                                          True to create a new element without checking whether one already exists.

                                          Returns

                                          The existing element with the same attributes and values if found, the new element if no match is found, or null if the tag parameter is not defined.

                                        method addTags

                                        addTags: (tags: MetaDefinition[], forceCreation?: boolean) => HTMLMetaElement[];
                                        • Retrieves or creates a set of <meta> tag elements in the current HTML document. In searching for an existing tag, Angular attempts to match the name or property attribute values in the provided tag definition, and verifies that all other attribute values are equal.

                                          Parameter tags

                                          An array of tag definitions to match or create.

                                          Parameter forceCreation

                                          True to create new elements without checking whether they already exist.

                                          Returns

                                          The matching elements if found, or the new elements.

                                        method getTag

                                        getTag: (attrSelector: string) => HTMLMetaElement | null;
                                        • Retrieves a <meta> tag element in the current HTML document.

                                          Parameter attrSelector

                                          The tag attribute and value to match against, in the format "tag_attribute='value string'".

                                          Returns

                                          The matching element, if any.

                                        method getTags

                                        getTags: (attrSelector: string) => HTMLMetaElement[];
                                        • Retrieves a set of <meta> tag elements in the current HTML document.

                                          Parameter attrSelector

                                          The tag attribute and value to match against, in the format "tag_attribute='value string'".

                                          Returns

                                          The matching elements, if any.

                                        method removeTag

                                        removeTag: (attrSelector: string) => void;
                                        • Removes an existing <meta> tag element from the current HTML document.

                                          Parameter attrSelector

                                          A tag attribute and value to match against, to identify an existing tag. A string in the format "tag_attribute=value string".

                                        method removeTagElement

                                        removeTagElement: (meta: HTMLMetaElement) => void;
                                        • Removes an existing <meta> tag element from the current HTML document.

                                          Parameter meta

                                          The tag definition to match against to identify an existing tag.

                                        method updateTag

                                        updateTag: (tag: MetaDefinition, selector?: string) => HTMLMetaElement | null;
                                        • Modifies an existing <meta> tag element in the current HTML document.

                                          Parameter tag

                                          The tag description with which to replace the existing tag content.

                                          Parameter selector

                                          A tag attribute and value to match against, to identify an existing tag. A string in the format "tag_attribute=value string". If not supplied, matches a tag with the same name or property attribute value as the replacement tag. The modified element.

                                        class ɵBrowserDomAdapter

                                        class ɵBrowserDomAdapter extends GenericBrowserDomAdapter {}
                                        • A DomAdapter powered by full browser DOM APIs.

                                          Tread carefully! Interacting with the DOM directly is dangerous and can introduce XSS risks.

                                        method createElement

                                        createElement: (tagName: string, doc?: Document) => HTMLElement;

                                          method createHtmlDocument

                                          createHtmlDocument: () => Document;

                                            method dispatchEvent

                                            dispatchEvent: (el: Node, evt: any) => void;

                                              method getBaseHref

                                              getBaseHref: (doc: Document) => string | null;

                                                method getCookie

                                                getCookie: (name: string) => string | null;

                                                  method getDefaultDocument

                                                  getDefaultDocument: () => Document;

                                                    method getGlobalEventTarget

                                                    getGlobalEventTarget: (doc: Document, target: string) => EventTarget | null;
                                                    • Deprecated

                                                      No longer being used in Ivy code. To be removed in version 14.

                                                    method getUserAgent

                                                    getUserAgent: () => string;

                                                      method isElementNode

                                                      isElementNode: (node: Node) => boolean;

                                                        method isShadowRoot

                                                        isShadowRoot: (node: any) => boolean;

                                                          method makeCurrent

                                                          static makeCurrent: () => void;

                                                            method onAndCancel

                                                            onAndCancel: (el: Node, evt: any, listener: any) => Function;

                                                              method remove

                                                              remove: (node: Node) => void;

                                                                method resetBaseElement

                                                                resetBaseElement: () => void;

                                                                  class ɵBrowserGetTestability

                                                                  class ɵBrowserGetTestability implements GetTestability {}

                                                                    method addToWindow

                                                                    addToWindow: (registry: TestabilityRegistry) => void;

                                                                      method findTestabilityInTree

                                                                      findTestabilityInTree: (
                                                                      registry: TestabilityRegistry,
                                                                      elem: any,
                                                                      findInAncestors: boolean
                                                                      ) => Testability | null;

                                                                        class ɵDomEventsPlugin

                                                                        class ɵDomEventsPlugin extends EventManagerPlugin {}

                                                                          constructor

                                                                          constructor(doc: any);

                                                                            property ɵfac

                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<ɵDomEventsPlugin, never>;

                                                                              property ɵprov

                                                                              static ɵprov: i0.ɵɵInjectableDeclaration<ɵDomEventsPlugin>;

                                                                                method addEventListener

                                                                                addEventListener: (
                                                                                element: HTMLElement,
                                                                                eventName: string,
                                                                                handler: Function
                                                                                ) => Function;

                                                                                  method removeEventListener

                                                                                  removeEventListener: (
                                                                                  target: any,
                                                                                  eventName: string,
                                                                                  callback: Function
                                                                                  ) => void;

                                                                                    method supports

                                                                                    supports: (eventName: string) => boolean;

                                                                                      class ɵDomRendererFactory2

                                                                                      class ɵDomRendererFactory2 implements RendererFactory2, OnDestroy {}

                                                                                        constructor

                                                                                        constructor(
                                                                                        eventManager: EventManager,
                                                                                        sharedStylesHost: ɵSharedStylesHost,
                                                                                        appId: string,
                                                                                        removeStylesOnCompDestroy: boolean,
                                                                                        doc: Document,
                                                                                        platformId: Object,
                                                                                        ngZone: NgZone,
                                                                                        nonce?: string
                                                                                        );

                                                                                          property ngZone

                                                                                          readonly ngZone: NgZone;

                                                                                            property ɵfac

                                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<ɵDomRendererFactory2, never>;

                                                                                              property ɵprov

                                                                                              static ɵprov: i0.ɵɵInjectableDeclaration<ɵDomRendererFactory2>;

                                                                                                property platformId

                                                                                                readonly platformId: Object;

                                                                                                  method createRenderer

                                                                                                  createRenderer: (element: any, type: RendererType2 | null) => Renderer2;

                                                                                                    method ngOnDestroy

                                                                                                    ngOnDestroy: () => void;

                                                                                                      class ɵDomSanitizerImpl

                                                                                                      class ɵDomSanitizerImpl extends DomSanitizer {}

                                                                                                        constructor

                                                                                                        constructor(_doc: any);

                                                                                                          property ɵfac

                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<ɵDomSanitizerImpl, never>;

                                                                                                            property ɵprov

                                                                                                            static ɵprov: i0.ɵɵInjectableDeclaration<ɵDomSanitizerImpl>;

                                                                                                              method bypassSecurityTrustHtml

                                                                                                              bypassSecurityTrustHtml: (value: string) => SafeHtml;

                                                                                                                method bypassSecurityTrustResourceUrl

                                                                                                                bypassSecurityTrustResourceUrl: (value: string) => SafeResourceUrl;

                                                                                                                  method bypassSecurityTrustScript

                                                                                                                  bypassSecurityTrustScript: (value: string) => SafeScript;

                                                                                                                    method bypassSecurityTrustStyle

                                                                                                                    bypassSecurityTrustStyle: (value: string) => SafeStyle;

                                                                                                                      method bypassSecurityTrustUrl

                                                                                                                      bypassSecurityTrustUrl: (value: string) => SafeUrl;

                                                                                                                        method sanitize

                                                                                                                        sanitize: (
                                                                                                                        ctx: SecurityContext,
                                                                                                                        value: SafeValue | string | null
                                                                                                                        ) => string | null;

                                                                                                                          class ɵHammerGesturesPlugin

                                                                                                                          class ɵHammerGesturesPlugin extends EventManagerPlugin {}
                                                                                                                          • Event plugin that adds Hammer support to an application.

                                                                                                                            HammerModule

                                                                                                                          constructor

                                                                                                                          constructor(
                                                                                                                          doc: any,
                                                                                                                          _config: HammerGestureConfig,
                                                                                                                          console: ɵConsole,
                                                                                                                          loader?: HammerLoader
                                                                                                                          );

                                                                                                                            property ɵfac

                                                                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                            ɵHammerGesturesPlugin,
                                                                                                                            [null, null, null, { optional: true }]
                                                                                                                            >;

                                                                                                                              property ɵprov

                                                                                                                              static ɵprov: i0.ɵɵInjectableDeclaration<ɵHammerGesturesPlugin>;

                                                                                                                                method addEventListener

                                                                                                                                addEventListener: (
                                                                                                                                element: HTMLElement,
                                                                                                                                eventName: string,
                                                                                                                                handler: Function
                                                                                                                                ) => Function;

                                                                                                                                  method isCustomEvent

                                                                                                                                  isCustomEvent: (eventName: string) => boolean;

                                                                                                                                    method supports

                                                                                                                                    supports: (eventName: string) => boolean;

                                                                                                                                      class ɵKeyEventsPlugin

                                                                                                                                      class ɵKeyEventsPlugin extends EventManagerPlugin {}
                                                                                                                                      • A browser plug-in that provides support for handling of key events in Angular.

                                                                                                                                      constructor

                                                                                                                                      constructor(doc: any);
                                                                                                                                      • Initializes an instance of the browser plug-in.

                                                                                                                                        Parameter doc

                                                                                                                                        The document in which key events will be detected.

                                                                                                                                      property ɵfac

                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<ɵKeyEventsPlugin, never>;

                                                                                                                                        property ɵprov

                                                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<ɵKeyEventsPlugin>;

                                                                                                                                          method addEventListener

                                                                                                                                          addEventListener: (
                                                                                                                                          element: HTMLElement,
                                                                                                                                          eventName: string,
                                                                                                                                          handler: Function
                                                                                                                                          ) => Function;
                                                                                                                                          • Registers a handler for a specific element and key event.

                                                                                                                                            Parameter element

                                                                                                                                            The HTML element to receive event notifications.

                                                                                                                                            Parameter eventName

                                                                                                                                            The name of the key event to listen for.

                                                                                                                                            Parameter handler

                                                                                                                                            A function to call when the notification occurs. Receives the event object as an argument.

                                                                                                                                            Returns

                                                                                                                                            The key event that was registered.

                                                                                                                                          method eventCallback

                                                                                                                                          static eventCallback: (
                                                                                                                                          fullKey: string,
                                                                                                                                          handler: Function,
                                                                                                                                          zone: NgZone
                                                                                                                                          ) => Function;
                                                                                                                                          • Configures a handler callback for a key event.

                                                                                                                                            Parameter fullKey

                                                                                                                                            The event name that combines all simultaneous keystrokes.

                                                                                                                                            Parameter handler

                                                                                                                                            The function that responds to the key event.

                                                                                                                                            Parameter zone

                                                                                                                                            The zone in which the event occurred.

                                                                                                                                            Returns

                                                                                                                                            A callback function.

                                                                                                                                          method matchEventFullKeyCode

                                                                                                                                          static matchEventFullKeyCode: (
                                                                                                                                          event: KeyboardEvent,
                                                                                                                                          fullKeyCode: string
                                                                                                                                          ) => boolean;
                                                                                                                                          • Determines whether the actual keys pressed match the configured key code string. The fullKeyCode event is normalized in the parseEventName method when the event is attached to the DOM during the addEventListener call. This is unseen by the end user and is normalized for internal consistency and parsing.

                                                                                                                                            Parameter event

                                                                                                                                            The keyboard event.

                                                                                                                                            Parameter fullKeyCode

                                                                                                                                            The normalized user defined expected key event string

                                                                                                                                            Returns

                                                                                                                                            boolean.

                                                                                                                                          method parseEventName

                                                                                                                                          static parseEventName: (
                                                                                                                                          eventName: string
                                                                                                                                          ) => { fullKey: string; domEventName: string } | null;
                                                                                                                                          • Parses the user provided full keyboard event definition and normalizes it for later internal use. It ensures the string is all lowercase, converts special characters to a standard spelling, and orders all the values consistently.

                                                                                                                                            Parameter eventName

                                                                                                                                            The name of the key event to listen for.

                                                                                                                                            Returns

                                                                                                                                            an object with the full, normalized string, and the dom event name or null in the case when the event doesn't match a keyboard event.

                                                                                                                                          method supports

                                                                                                                                          supports: (eventName: string) => boolean;
                                                                                                                                          • Reports whether a named key event is supported.

                                                                                                                                            Parameter eventName

                                                                                                                                            The event name to query. True if the named key event is supported.

                                                                                                                                          class ɵSharedStylesHost

                                                                                                                                          class ɵSharedStylesHost implements OnDestroy {}

                                                                                                                                            constructor

                                                                                                                                            constructor(doc: Document, appId: string, nonce?: string, platformId?: {});

                                                                                                                                              property ɵfac

                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                                              ɵSharedStylesHost,
                                                                                                                                              [null, null, { optional: true }, null]
                                                                                                                                              >;

                                                                                                                                                property ɵprov

                                                                                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<ɵSharedStylesHost>;

                                                                                                                                                  property platformId

                                                                                                                                                  readonly platformId: {};

                                                                                                                                                    method addHost

                                                                                                                                                    addHost: (hostNode: Node) => void;

                                                                                                                                                      method addStyles

                                                                                                                                                      addStyles: (styles: string[]) => void;

                                                                                                                                                        method ngOnDestroy

                                                                                                                                                        ngOnDestroy: () => void;

                                                                                                                                                          method removeHost

                                                                                                                                                          removeHost: (hostNode: Node) => void;

                                                                                                                                                            method removeStyles

                                                                                                                                                            removeStyles: (styles: string[]) => void;

                                                                                                                                                              class Title

                                                                                                                                                              class Title {}
                                                                                                                                                              • A service that can be used to get and set the title of a current HTML document.

                                                                                                                                                                Since an Angular application can't be bootstrapped on the entire HTML document (<html> tag) it is not possible to bind to the text property of the HTMLTitleElement elements (representing the <title> tag). Instead, this service can be used to set and get the current title value.

                                                                                                                                                              constructor

                                                                                                                                                              constructor(_doc: any);

                                                                                                                                                                property ɵfac

                                                                                                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<Title, never>;

                                                                                                                                                                  property ɵprov

                                                                                                                                                                  static ɵprov: i0.ɵɵInjectableDeclaration<Title>;

                                                                                                                                                                    method getTitle

                                                                                                                                                                    getTitle: () => string;
                                                                                                                                                                    • Get the title of the current HTML document.

                                                                                                                                                                    method setTitle

                                                                                                                                                                    setTitle: (newTitle: string) => void;
                                                                                                                                                                    • Set the title of the current HTML document.

                                                                                                                                                                      Parameter newTitle

                                                                                                                                                                    Interfaces

                                                                                                                                                                    interface HydrationFeature

                                                                                                                                                                    interface HydrationFeature<FeatureKind extends HydrationFeatureKind> {}
                                                                                                                                                                    • Helper type to represent a Hydration feature.

                                                                                                                                                                    property ɵkind

                                                                                                                                                                    ɵkind: FeatureKind;

                                                                                                                                                                      property ɵproviders

                                                                                                                                                                      ɵproviders: Provider[];

                                                                                                                                                                        interface SafeHtml

                                                                                                                                                                        interface SafeHtml extends SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use as HTML.

                                                                                                                                                                        interface SafeResourceUrl

                                                                                                                                                                        interface SafeResourceUrl extends SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use as a URL to load executable code from.

                                                                                                                                                                        interface SafeScript

                                                                                                                                                                        interface SafeScript extends SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use as JavaScript.

                                                                                                                                                                        interface SafeStyle

                                                                                                                                                                        interface SafeStyle extends SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use as style (CSS).

                                                                                                                                                                        interface SafeUrl

                                                                                                                                                                        interface SafeUrl extends SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use as a URL linking to a document.

                                                                                                                                                                        interface SafeValue

                                                                                                                                                                        interface SafeValue {}
                                                                                                                                                                        • Marker interface for a value that's safe to use in a particular context.

                                                                                                                                                                        Enums

                                                                                                                                                                        enum HydrationFeatureKind

                                                                                                                                                                        const enum HydrationFeatureKind {
                                                                                                                                                                        NoDomReuseFeature = 0,
                                                                                                                                                                        NoHttpTransferCache = 1,
                                                                                                                                                                        }
                                                                                                                                                                        • The list of features as an enum to uniquely type each HydrationFeature.

                                                                                                                                                                          See Also

                                                                                                                                                                        member NoDomReuseFeature

                                                                                                                                                                        NoDomReuseFeature = 0

                                                                                                                                                                          member NoHttpTransferCache

                                                                                                                                                                          NoHttpTransferCache = 1

                                                                                                                                                                            Type Aliases

                                                                                                                                                                            type ApplicationConfig

                                                                                                                                                                            type ApplicationConfig = ApplicationConfig_2;
                                                                                                                                                                            • Set of config options available during the application bootstrap operation.

                                                                                                                                                                              Deprecated

                                                                                                                                                                              ApplicationConfig has moved, please import ApplicationConfig from @angular/core instead.

                                                                                                                                                                            type HammerLoader

                                                                                                                                                                            type HammerLoader = () => Promise<void>;
                                                                                                                                                                            • Function that loads HammerJS, returning a promise that is resolved once HammerJs is loaded.

                                                                                                                                                                            type MetaDefinition

                                                                                                                                                                            type MetaDefinition = {
                                                                                                                                                                            charset?: string;
                                                                                                                                                                            content?: string;
                                                                                                                                                                            httpEquiv?: string;
                                                                                                                                                                            id?: string;
                                                                                                                                                                            itemprop?: string;
                                                                                                                                                                            name?: string;
                                                                                                                                                                            property?: string;
                                                                                                                                                                            scheme?: string;
                                                                                                                                                                            url?: string;
                                                                                                                                                                            } & {
                                                                                                                                                                            [prop: string]: string;
                                                                                                                                                                            };
                                                                                                                                                                            • Represents the attributes of an HTML <meta> element. The element itself is represented by the internal HTMLMetaElement.

                                                                                                                                                                              See Also

                                                                                                                                                                              • [HTML meta tag](https://developer.mozilla.org/docs/Web/HTML/Element/meta)

                                                                                                                                                                              • Meta

                                                                                                                                                                            type StateKey

                                                                                                                                                                            type StateKey<T> = StateKey_2<T>;
                                                                                                                                                                            • A type-safe key to use with TransferState.

                                                                                                                                                                              Example:

                                                                                                                                                                              const COUNTER_KEY = makeStateKey<number>('counter');
                                                                                                                                                                              let value = 10;
                                                                                                                                                                              transferState.set(COUNTER_KEY, value);

                                                                                                                                                                              Deprecated

                                                                                                                                                                              StateKey has moved, please import StateKey from @angular/core instead.

                                                                                                                                                                            type TransferState

                                                                                                                                                                            type TransferState = TransferState_2;
                                                                                                                                                                            • A key value store that is transferred from the application on the server side to the application on the client side.

                                                                                                                                                                              The TransferState is available as an injectable token. On the client, just inject this token using DI and use it, it will be lazily initialized. On the server it's already included if renderApplication function is used. Otherwise, import the ServerTransferStateModule module to make the TransferState available.

                                                                                                                                                                              The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only boolean, number, string, null and non-class objects will be serialized and deserialized in a non-lossy manner.

                                                                                                                                                                              Deprecated

                                                                                                                                                                              TransferState has moved, please import TransferState from @angular/core instead.

                                                                                                                                                                            Package Files (1)

                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                            Peer Dependencies (3)

                                                                                                                                                                            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/@angular/platform-browser.

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