angular_ts - v0.35.5

angular_ts

Build AngularTS interfaces in Gleam while keeping the page in HTML.

Add both packages:

npm install @angular-wave/angular.ts
gleam add angular_ts

Register a module, then bootstrap it after the page has loaded:

import angular_ts as ng
import angular_ts/component
import angular_ts/module

fn controller() { Nil }

pub fn main() {
  ng.create_module("app")
  |> module.component(
    "welcomeCard",
    component.new("<p>Welcome</p>", ng.inject0(controller)),
  )
  |> ng.bootstrap_body
}

Start with server-rendered HTML and add components only where the page needs client-side behavior. See the package README and examples/basic_app for the complete build and script-loading setup.

Types

CookieOptions

</> 
pub type CookieOptions =
  cookie.CookieOptions

CookieStoreOptions

</> 
pub type CookieStoreOptions =
  cookie.CookieStoreOptions

CurrencyFilterOptions

</> 
pub type CurrencyFilterOptions =
  filters.CurrencyFilterOptions

DateFilterOptions

</> 
pub type DateFilterOptions =
  filters.DateFilterOptions

Element

</> 
pub type Element =
  dynamic.Dynamic

EntryFilterItem

</> 
pub type EntryFilterItem(key, value) =
  filters.EntryFilterItem(key, value)

GeolocationValue

</> 
pub type GeolocationValue =
  @internal GeolocationValue

HttpMethod

</> 
pub type HttpMethod =
  http.HttpMethod

HttpRequestConfig

</> 
pub type HttpRequestConfig =
  http.HttpRequestConfig

HttpRequestOptions

</> 
pub type HttpRequestOptions =
  http.HttpRequestOptions

Injectable

</> 
pub type Injectable(value) =
  injectable.Injectable(value)

Injector

</> 
pub type Injector =
  @internal InjectorService(dynamic.Dynamic)

NgModule

</> 
pub type NgModule =
  module.NgModule

NumberFilterOptions

</> 
pub type NumberFilterOptions =
  filters.NumberFilterOptions

RelativeTimeFilterOptions

</> 
pub type RelativeTimeFilterOptions =
  filters.RelativeTimeFilterOptions

StorageBackend

</> 
pub type StorageBackend =
  storage.StorageBackend

StorageType

</> 
pub type StorageType =
  storage.StorageType

Token

</> 
pub type Token(value) =
  token.Token(value)

WasmBinding

</> 
pub type WasmBinding =
  dynamic.Dynamic

WasmBindingOptions

</> 
pub type WasmBindingOptions =
  dynamic.Dynamic

WasmError

</> 
pub type WasmError =
  dynamic.Dynamic

WasmErrorCode

</> 
pub type WasmErrorCode =
  dynamic.Dynamic

WasmLoadOptions

</> 
pub type WasmLoadOptions =
  dynamic.Dynamic

WasmResource

</> 
pub type WasmResource =
  dynamic.Dynamic

WasmResourceStatus

</> 
pub type WasmResourceStatus =
  dynamic.Dynamic

WasmService

</> 
pub type WasmService =
  dynamic.Dynamic

WasmSource

</> 
pub type WasmSource =
  dynamic.Dynamic

WasmTarget

</> 
pub type WasmTarget =
  dynamic.Dynamic

WorkerConfig

</> 
pub type WorkerConfig(receive) =
  worker.WorkerConfig(receive)

WorkerError

</> 
pub type WorkerError =
  @internal WorkerError

WorkerErrorCode

</> 
pub type WorkerErrorCode =
  @internal WorkerErrorCode

WorkerHandle

</> 
pub type WorkerHandle(send, receive) =
  @internal WorkerHandle(send, receive)

WorkerModelMessage

</> 
pub type WorkerModelMessage(model) =
  @internal WorkerModelMessage(model)

WorkerRequest

</> 
pub type WorkerRequest(payload) =
  @internal WorkerRequest(payload)

WorkerRequestOptions

</> 
pub type WorkerRequestOptions =
  worker.WorkerRequestOptions

WorkerResponse

</> 
pub type WorkerResponse(result) =
  @internal WorkerResponse(result)

WorkerService

</> 
pub type WorkerService =
  @internal WorkerService

WorkerStatus

</> 
pub type WorkerStatus =
  @internal WorkerStatus

Values

bootstrap

</> 
pub fn bootstrap(
  root: dynamic.Dynamic,
  modules: List(String),
) -> @internal InjectorService(dynamic.Dynamic)

bootstrap_body

</> 
pub fn bootstrap_body(
  app: module.NgModule,
) -> @internal InjectorService(dynamic.Dynamic)

create_module

</> 
pub fn create_module(name: String) -> module.NgModule

create_module_with_requires

</> 
pub fn create_module_with_requires(
  name: String,
  requires: List(String),
) -> module.NgModule

get_module

</> 
pub fn get_module(name: String) -> module.NgModule

inject0

</> 
pub fn inject0(
  factory: fn() -> value,
) -> injectable.Injectable(value)

inject1

</> 
pub fn inject1(
  token_a: token.Token(a),
  factory: fn(a) -> value,
) -> injectable.Injectable(value)

inject2

</> 
pub fn inject2(
  token_a: token.Token(a),
  token_b: token.Token(b),
  factory: fn(a, b) -> value,
) -> injectable.Injectable(value)

token

</> 
pub fn token(name: String) -> token.Token(value)
✨ Search Document