Package org.angular.ts.ng

Interface AngularService

@JsType(isNative=true, name="ng.AngularService", namespace="<global>") public interface AngularService
Main AngularTS runtime entry point with the full built-in `ng` module configured by default.

  • Method Details

    • bootstrap

      InjectorService<Object> bootstrap(AngularService.BootstrapElementUnionType element, elemental2.core.JsArray<Object> modules)
      Use this function to manually start up AngularTS application. AngularTS will detect if it has been loaded into the browser more than once and only allow the first loaded script to be bootstrapped and will report a warning to the browser console for each of the subsequent scripts. This prevents strange results in applications, where otherwise multiple instances of AngularTS try to work on the DOM. **Note:** Do not bootstrap the app on an element with a directive that uses transclusion, such as `ng-if`, `ng-include`, or `ng-view`. Doing this misplaces the app root element and injector, causing animations to stop working and making the injector inaccessible from outside the app. ```html <!doctype html> <html> <body> <div ng-controller="WelcomeController"> {{greeting}} </div> <script src="angular.js"></script> <script> let app = angular.module('demo', []) .controller('WelcomeController', ['$scope', function($scope) { $scope.greeting = 'Welcome!'; }]); angular.bootstrap(document, ['demo']); </script> </body> </html> ```
      Parameters:
      element - DOM element which is the root of AngularTS application.
      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. See `angular.module()`.
      Returns:
      Method result.

    • bootstrap

      @JsOverlay default InjectorService<Object> bootstrap(Document element, elemental2.core.JsArray<Object> modules)
      Use this function to manually start up AngularTS application. AngularTS will detect if it has been loaded into the browser more than once and only allow the first loaded script to be bootstrapped and will report a warning to the browser console for each of the subsequent scripts. This prevents strange results in applications, where otherwise multiple instances of AngularTS try to work on the DOM. **Note:** Do not bootstrap the app on an element with a directive that uses transclusion, such as `ng-if`, `ng-include`, or `ng-view`. Doing this misplaces the app root element and injector, causing animations to stop working and making the injector inaccessible from outside the app. ```html <!doctype html> <html> <body> <div ng-controller="WelcomeController"> {{greeting}} </div> <script src="angular.js"></script> <script> let app = angular.module('demo', []) .controller('WelcomeController', ['$scope', function($scope) { $scope.greeting = 'Welcome!'; }]); angular.bootstrap(document, ['demo']); </script> </body> </html> ```
      Parameters:
      element - DOM element which is the root of AngularTS application.
      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. See `angular.module()`.
      Returns:
      Method result.

    • bootstrap

      @JsOverlay default InjectorService<Object> bootstrap(elemental2.dom.HTMLElement element, elemental2.core.JsArray<Object> modules)
      Use this function to manually start up AngularTS application. AngularTS will detect if it has been loaded into the browser more than once and only allow the first loaded script to be bootstrapped and will report a warning to the browser console for each of the subsequent scripts. This prevents strange results in applications, where otherwise multiple instances of AngularTS try to work on the DOM. **Note:** Do not bootstrap the app on an element with a directive that uses transclusion, such as `ng-if`, `ng-include`, or `ng-view`. Doing this misplaces the app root element and injector, causing animations to stop working and making the injector inaccessible from outside the app. ```html <!doctype html> <html> <body> <div ng-controller="WelcomeController"> {{greeting}} </div> <script src="angular.js"></script> <script> let app = angular.module('demo', []) .controller('WelcomeController', ['$scope', function($scope) { $scope.greeting = 'Welcome!'; }]); angular.bootstrap(document, ['demo']); </script> </body> </html> ```
      Parameters:
      element - DOM element which is the root of AngularTS application.
      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. See `angular.module()`.
      Returns:
      Method result.

    • bootstrap

      @JsOverlay default InjectorService<Object> bootstrap(String element, elemental2.core.JsArray<Object> modules)
      Use this function to manually start up AngularTS application. AngularTS will detect if it has been loaded into the browser more than once and only allow the first loaded script to be bootstrapped and will report a warning to the browser console for each of the subsequent scripts. This prevents strange results in applications, where otherwise multiple instances of AngularTS try to work on the DOM. **Note:** Do not bootstrap the app on an element with a directive that uses transclusion, such as `ng-if`, `ng-include`, or `ng-view`. Doing this misplaces the app root element and injector, causing animations to stop working and making the injector inaccessible from outside the app. ```html <!doctype html> <html> <body> <div ng-controller="WelcomeController"> {{greeting}} </div> <script src="angular.js"></script> <script> let app = angular.module('demo', []) .controller('WelcomeController', ['$scope', function($scope) { $scope.greeting = 'Welcome!'; }]); angular.bootstrap(document, ['demo']); </script> </body> </html> ```
      Parameters:
      element - DOM element which is the root of AngularTS application.
      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. See `angular.module()`.
      Returns:
      Method result.

    • call

      elemental2.promise.Promise<Object> call(String input)
      Await result. Accepts a single string: `"<target>.<expression>"`
      Parameters:
      input - Value supplied for the input parameter.
      Returns:
      Method result.

    • dispatchEvent

      boolean dispatchEvent(elemental2.dom.Event event)
      Dispatches an invocation event to either an injectable service or a named scope. The event `type` identifies the target and the payload contains the expression to evaluate against that target.
      Parameters:
      event - Value supplied for the event parameter.
      Returns:
      Method result.

    • emit

      void emit(String input)
      Fire-and-forget. Accepts a single string: `"<target>.<expression>"`
      Parameters:
      input - Value supplied for the input parameter.

    • errorFormattingConfig

      ErrorFormattingConfig errorFormattingConfig(ErrorFormattingConfig config)
      Configure how values embedded in framework error messages are formatted.
      Parameters:
      config - Value supplied for the config parameter.
      Returns:
      Method result.

    • getController

      Scope getController(elemental2.dom.Element element, String name)
      Retrieve the controller instance cached on a compiled DOM element.
      Parameters:
      element - The DOM element to get data from.
      name - Controller name.
      Returns:
      Method result.

    • getCurrentInjector

      @JsProperty InjectorService<Object> getCurrentInjector()
      Application injector, available after `bootstrap()` or `injector()` completes.

    • getEventBus

      @JsProperty EventBusService getEventBus()
      Application-wide event bus, available after bootstrap providers are created.

    • getInjector

      InjectorService<Object> getInjector(elemental2.dom.Element element)
      Retrieve the injector cached on a bootstrapped DOM element.
      Parameters:
      element - Value supplied for the element parameter.
      Returns:
      Method result.

    • getNormalizedAttr

      String getNormalizedAttr(Node element, String normalizedName)
      Read an element attribute by normalized directive-style name.
      Parameters:
      element - Value supplied for the element parameter.
      normalizedName - Value supplied for the normalizedName parameter.
      Returns:
      Method result.

    • getNormalizedAttrName

      String getNormalizedAttrName(Node element, String normalizedName)
      Return the actual DOM attribute name for a normalized directive-style name.
      Parameters:
      element - Value supplied for the element parameter.
      normalizedName - Value supplied for the normalizedName parameter.
      Returns:
      Method result.

    • getRootScope

      @JsProperty Scope getRootScope()
      Root scope for the bootstrapped application.

    • getScope

      Scope getScope(elemental2.dom.Element element)
      Retrieve the scope cached on a compiled DOM element.
      Parameters:
      element - The DOM element to get data from.
      Returns:
      Method result.

    • getScopeByName

      Scope getScopeByName(String name)
      Find a scope by its registered `scopeName`.
      Parameters:
      name - Scope name to search for.
      Returns:
      Method result.

    • getScopeElement

      @JsProperty(name="ScopeElement") ScopeElement<Object> getScopeElement()
      Base class for user-authored AngularTS custom elements.

    • getSubapps

      @JsProperty elemental2.core.JsArray<Object> getSubapps()
      Sub-application instances created when multiple `ng-app` roots are initialized.

    • getTokens

      @JsProperty Object getTokens()
      Public injection token names keyed by token value.

    • getVersion

      @JsProperty String getVersion()
      AngularTS version string replaced at build time.

    • getView

      @JsProperty Object getView()
      Explicit programmatic-view binding and element helpers.

    • hasNormalizedAttr

      boolean hasNormalizedAttr(Node element, String normalizedName)
      Return whether an element has an attribute matching a normalized name.
      Parameters:
      element - Value supplied for the element parameter.
      normalizedName - Value supplied for the normalizedName parameter.
      Returns:
      Method result.

    • init

      @JsOverlay default void init(Document element)
      Find `ng-app` roots under the provided element and bootstrap them. The first root uses this instance. Additional roots are bootstrapped as sub-applications and stored in subapps.
      Parameters:
      element - Root element or document to scan.

    • init

      @JsOverlay default void init(elemental2.dom.HTMLElement element)
      Find `ng-app` roots under the provided element and bootstrap them. The first root uses this instance. Additional roots are bootstrapped as sub-applications and stored in subapps.
      Parameters:
      element - Root element or document to scan.

    • init

      void init(AngularService.InitElementUnionType element)
      Find `ng-app` roots under the provided element and bootstrap them. The first root uses this instance. Additional roots are bootstrapped as sub-applications and stored in subapps.
      Parameters:
      element - Root element or document to scan.

    • injector

      InjectorService<Object> injector(elemental2.core.JsArray<Object> modules)
      Create a standalone injector without bootstrapping the DOM.
      Parameters:
      modules - Module names or config functions to load.
      Returns:
      Method result.

    • module

      NgModule module(String name, elemental2.core.JsArray<String> requires, Object configFn)
      The `angular.module` is a global place for creating, registering and retrieving AngularTS modules. All modules (AngularTS core or 3rd party) that should be available to an application must be registered using this mechanism. Passing one argument retrieves an existing ng.NgModule, whereas passing more than one argument creates a new ng.NgModule # Module A module is a collection of services, directives, controllers, filters, workers, WebAssembly modules, and configuration information. `angular.module` is used to configure the auto.$injector `$injector`. ```js // Create a new module let myModule = angular.module('myModule', []); // register a new service myModule.value('appName', 'MyCoolApp'); // configure built-in services with typed object config. myModule.config({ location: { hashPrefix: '!', }, }); ``` Then you can create an injector and load your modules like this: ```js let injector = angular.injector(['ng', 'myModule']) ``` However it's more likely that you'll use the `ng-app` directive or `bootstrap()` to simplify this process.
      Parameters:
      name - The name of the module to create or retrieve.
      requires - If specified then new module is being created. If unspecified then the module is being retrieved for further configuration.
      configFn - Optional configuration function for the module that gets passed to `NgModule.config()`.
      Returns:
      Method result.

    • registerNgModule

      NgModule registerNgModule()
      Registers the configured built-in `ng` module for this runtime instance.
      Returns:
      Method result.

    • setCurrentInjector

      @JsProperty void setCurrentInjector(InjectorService<Object> currentInjector)
      Application injector, available after `bootstrap()` or `injector()` completes.

    • setEventBus

      @JsProperty void setEventBus(EventBusService eventBus)
      Application-wide event bus, available after bootstrap providers are created.

    • setRootScope

      @JsProperty void setRootScope(Scope rootScope)
      Root scope for the bootstrapped application.

    • setScopeElement

      @JsProperty(name="ScopeElement") void setScopeElement(ScopeElement<Object> ScopeElement)
      Base class for user-authored AngularTS custom elements.

    • setSubapps

      @JsProperty void setSubapps(elemental2.core.JsArray<Object> subapps)
      Sub-application instances created when multiple `ng-app` roots are initialized.

    • setTokens

      @JsProperty void setTokens(Object tokens)
      Public injection token names keyed by token value.

    • setVersion

      @JsProperty void setVersion(String version)
      AngularTS version string replaced at build time.

    • setView

      @JsProperty void setView(Object view)
      Explicit programmatic-view binding and element helpers.

    • tags

      Object tags(String namespaceUri)
      JSX-free real-DOM tag factories for programmatic component views.
      Parameters:
      namespaceUri - Value supplied for the namespaceUri parameter.
      Returns:
      Method result.