@ngx-translate/core

@ngx-translate/core

Version 16.0.4
Published 4 months ago
142 kB
1 dependency
MIT license

Install

npm i @ngx-translate/core

yarn add @ngx-translate/core

pnpm add @ngx-translate/core

Overview

Translation library (i18n) for Angular

Index

Variables

variable DEFAULT_LANGUAGE

const DEFAULT_LANGUAGE: InjectionToken<string>;

variable ISOLATE_TRANSLATE_SERVICE

const ISOLATE_TRANSLATE_SERVICE: InjectionToken<string>;

variable USE_DEFAULT_LANG

const USE_DEFAULT_LANG: InjectionToken<string>;

variable USE_EXTEND

const USE_EXTEND: InjectionToken<string>;

Functions

function equals

equals: (o1: any, o2: any) => boolean;

Determines if two objects or two values are equivalent.
Two objects or values are considered equivalent if at least one of the following is true:
* Both objects or values pass === comparison. * Both objects or values are of the same type and all of their properties are equal by comparing them with equals.
Parameter o1
Object or value to compare.
Parameter o2
Object or value to compare.
Returns
true if arguments are equal.

function getValue

getValue: (target: any, key: string) => any;

Gets a value from an object by composed key getValue({ key1: { keyA: 'valueI' }}, 'key1.keyA') ==> 'valueI'
Parameter target
Parameter key

function isArray

isArray: (value: any) => boolean;

function isDefined

isDefined: (value: any) => boolean;

function isDict

isDict: (value: any) => boolean;

function isFunction

isFunction: (value: any) => boolean;

function isObject

isObject: (value: any) => boolean;

function isString

isString: (value: any) => boolean;

function mergeDeep

mergeDeep: (target: any, source: any) => any;

function provideTranslateService

provideTranslateService: (
    config?: TranslateModuleConfig
) => EnvironmentProviders;

function setValue

setValue: (target: any, key: string, value: any) => void;

Gets a value from an object by composed key parser.setValue({a:{b:{c: "test"}}}, 'a.b.c', "test2") ==> {a:{b:{c: "test2"}}}
Parameter target
an object
Parameter key
E.g. "a.b.c"
Parameter value
to set

Classes

class FakeMissingTranslationHandler

class FakeMissingTranslationHandler implements MissingTranslationHandler {}

This handler is just a placeholder that does nothing, in case you don't need a missing translation handler at all

property ɵfac

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

property ɵprov

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

method handle

handle: (params: MissingTranslationHandlerParams) => string;

class MissingTranslationHandler

abstract class MissingTranslationHandler {}

method handle

abstract handle: (
    params: MissingTranslationHandlerParams
) => Translation | Observable<Translation>;

A function that handles missing translations.
Parameter params
context for resolving a missing translation
Returns
a value or an observable
If it returns a value, then this value is used. If it returns an observable, the value returned by this observable will be used (except if the method was "instant"). If it returns undefined, the key will be used as a value

class TranslateCompiler

abstract class TranslateCompiler {}

method compile

abstract compile: (value: string, lang: string) => InterpolatableTranslation;

method compileTranslations

abstract compileTranslations: (
    translations: Translation,
    lang: string
) => InterpolatableTranslationObject;

class TranslateDefaultParser

class TranslateDefaultParser extends TranslateParser {}

property ɵfac

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

property ɵprov

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

property templateMatcher

templateMatcher: RegExp;

method interpolate

interpolate: (
    expr: InterpolateFunction | string,
    params?: InterpolationParameters
) => string | undefined;

class TranslateDirective

class TranslateDirective implements AfterViewChecked, OnDestroy {}

constructor

constructor(
    translateService: TranslateService,
    element: ElementRef,
    _ref: ChangeDetectorRef
);

property currentParams

currentParams?: InterpolationParameters;

property key

key: string;

property lastParams

lastParams?: InterpolationParameters;

property onDefaultLangChangeSub

onDefaultLangChangeSub: Subscription;

property onLangChangeSub

onLangChangeSub: Subscription;

property onTranslationChangeSub

onTranslationChangeSub: Subscription;

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    TranslateDirective,
    '[translate],[ngx-translate]',
    never,
    {
        translate: { alias: 'translate'; required: false };
        translateParams: { alias: 'translateParams'; required: false };
    },
    {},
    never,
    never,
    true,
    never
>;

property ɵfac

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

method checkNodes

checkNodes: (
    forceUpdate?: boolean,
    translations?: InterpolatableTranslation
) => void;

method getContent

getContent: (node: ExtendedNode) => string;

method ngAfterViewChecked

ngAfterViewChecked: () => void;

method ngOnDestroy

ngOnDestroy: () => void;

method setContent

setContent: (node: ExtendedNode, content: string) => void;

method updateValue

updateValue: (
    key: string,
    node: ExtendedNode,
    translations?: InterpolatableTranslation
) => void;

class TranslateFakeCompiler

class TranslateFakeCompiler extends TranslateCompiler {}

This compiler is just a placeholder that does nothing, in case you don't need a compiler at all

property ɵfac

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

property ɵprov

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

method compile

compile: (value: string, lang: string) => string | InterpolateFunction;

method compileTranslations

compileTranslations: (
    translations: InterpolatableTranslationObject,
    lang: string
) => InterpolatableTranslationObject;

class TranslateFakeLoader

class TranslateFakeLoader extends TranslateLoader {}

This loader is just a placeholder that does nothing, in case you don't need a loader at all

property ɵfac

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

property ɵprov

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

method getTranslation

getTranslation: (lang: string) => Observable<TranslationObject>;

class TranslateLoader

abstract class TranslateLoader {}

method getTranslation

abstract getTranslation: (lang: string) => Observable<TranslationObject>;

class TranslateModule

class TranslateModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    TranslateModule,
    never,
    [typeof i1.TranslatePipe, typeof i2.TranslateDirective],
    [typeof i1.TranslatePipe, typeof i2.TranslateDirective]
>;

method forChild

static forChild: (
    config?: TranslateModuleConfig
) => ModuleWithProviders<TranslateModule>;

Use this method in your other (non-root) modules to import the directive/pipe

method forRoot

static forRoot: (
    config?: TranslateModuleConfig
) => ModuleWithProviders<TranslateModule>;

Use this method in your root module to provide the TranslateService

class TranslateParser

abstract class TranslateParser {}

method interpolate

abstract interpolate: (
    expr: InterpolateFunction | string,
    params?: InterpolationParameters
) => string | undefined;

Interpolates a string to replace parameters "This is a {{ key }}" ==> "This is a value", with params = { key: "value" }
Parameter expr
Parameter params

class TranslatePipe

class TranslatePipe implements PipeTransform, OnDestroy {}

constructor

constructor(translate: TranslateService, _ref: ChangeDetectorRef);

property lastKey

lastKey: string;

property lastParams

lastParams: InterpolationParameters[];

property onDefaultLangChange

onDefaultLangChange: any;

property onLangChange

onLangChange: any;

property onTranslationChange

onTranslationChange: any;

property ɵfac

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

property ɵpipe

static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePipe, 'translate', true>;

property ɵprov

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

property value

value: any;

method ngOnDestroy

ngOnDestroy: () => void;

method transform

transform: (query: string, ...args: any[]) => any;

method updateValue

updateValue: (
    key: string,
    interpolateParams?: object,
    translations?: InterpolatableTranslationObject
) => void;

class TranslateService

class TranslateService {}

constructor

constructor(
    store: TranslateStore,
    currentLoader: TranslateLoader,
    compiler: TranslateCompiler,
    parser: TranslateParser,
    missingTranslationHandler: MissingTranslationHandler,
    useDefaultLang: boolean,
    isolate: boolean,
    extend: boolean,
    defaultLanguage: string
);

Parameter store
an instance of the store (that is supposed to be unique)
Parameter currentLoader
An instance of the loader currently used
Parameter compiler
An instance of the compiler currently used
Parameter parser
An instance of the parser currently used
Parameter missingTranslationHandler
A handler for missing translations.
Parameter useDefaultLang
whether we should use default language translation when current language translation is missing.
Parameter isolate
whether this service should use the store or not
Parameter extend
To make a child module extend (and use) translations from parent modules.
Parameter defaultLanguage
Set the default language using configuration

property compiler

compiler: TranslateCompiler;

property currentLang

currentLang: string;

The lang currently used

property currentLoader

currentLoader: TranslateLoader;

property defaultLang

defaultLang: string;

The default lang to fallback when translations are missing on the current lang

property langs

langs: string[];

an array of langs

property missingTranslationHandler

missingTranslationHandler: MissingTranslationHandler;

property onDefaultLangChange

readonly onDefaultLangChange: EventEmitter<DefaultLangChangeEvent>;

An EventEmitter to listen to default lang change events onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => { // do something });

property onLangChange

readonly onLangChange: EventEmitter<LangChangeEvent>;

An EventEmitter to listen to lang change events onLangChange.subscribe((params: LangChangeEvent) => { // do something });

property onTranslationChange

readonly onTranslationChange: EventEmitter<TranslationChangeEvent>;

An EventEmitter to listen to translation change events onTranslationChange.subscribe((params: TranslationChangeEvent) => { // do something });

property ɵfac

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

property ɵprov

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

property parser

parser: TranslateParser;

property store

store: TranslateStore;

property translations

translations: Record<string, InterpolatableTranslationObject>;

a list of translations per lang

method addLangs

addLangs: (langs: string[]) => void;

Add available languages

method get

get: (
    key: string | string[],
    interpolateParams?: InterpolationParameters
) => Observable<any>;

Gets the translated value of a key (or an array of keys)
Returns
the translated key, or an object of translated keys

method getBrowserCultureLang

getBrowserCultureLang: () => string | undefined;

Returns the culture language code name from the browser, e.g. "de-DE"

method getBrowserLang

getBrowserLang: () => string | undefined;

Returns the language code name from the browser, e.g. "de"

method getDefaultLang

getDefaultLang: () => string;

Gets the default language used

method getLangs

getLangs: () => string[];

Returns an array of currently available langs

method getParsedResult

getParsedResult: (
    translations: InterpolatableTranslation,
    key: string | string[],
    interpolateParams?: InterpolationParameters
) =>
    | Translation
    | TranslationObject
    | Observable<Translation | TranslationObject>;

Returns the parsed result of the translations

method getStreamOnTranslationChange

getStreamOnTranslationChange: (
    key: string | string[],
    interpolateParams?: InterpolationParameters
) => Observable<any>;

Returns a stream of translated values of a key (or an array of keys) which updates whenever the translation changes.
Returns
A stream of the translated key, or an object of translated keys

method getTranslation

getTranslation: (lang: string) => Observable<InterpolatableTranslationObject>;

Gets an object of translations for a given language with the current loader and passes it through the compiler
Deprecated
This function is meant for internal use. There should be no reason to use outside this service. You can plug into this functionality by using a customer TranslateLoader or TranslateCompiler. To load a new language use setDefaultLang() and/or use()

method instant

instant: (
    key: string | string[],
    interpolateParams?: InterpolationParameters
) => Translation | TranslationObject;

Returns a translation instantly from the internal state of loaded translation. All rules regarding the current language, the preferred language of even fallback languages will be used except any promise handling.

method reloadLang

reloadLang: (lang: string) => Observable<InterpolatableTranslationObject>;

Allows to reload the lang file from the file

method resetLang

resetLang: (lang: string) => void;

Deletes inner translation

method set

set: (key: string, translation: Translation, lang?: string) => void;

Sets the translated value of a key, after compiling it

method setDefaultLang

setDefaultLang: (lang: string) => void;

Sets the default language to use as a fallback

method setTranslation

setTranslation: (
    lang: string,
    translations: InterpolatableTranslationObject,
    shouldMerge?: boolean
) => void;

Manually sets an object of translations for a given language after passing it through the compiler

method stream

stream: (
    key: string | string[],
    interpolateParams?: InterpolationParameters
) => Observable<any>;

Returns a stream of translated values of a key (or an array of keys) which updates whenever the language changes.
Returns
A stream of the translated key, or an object of translated keys

method use

use: (lang: string) => Observable<InterpolatableTranslationObject>;

Changes the lang currently used

class TranslateStore

class TranslateStore {}

property currentLang

currentLang: string;

The lang currently used

property defaultLang

defaultLang: string;

The default lang to fallback when translations are missing on the current lang

property langs

langs: string[];

an array of langs

property onDefaultLangChange

onDefaultLangChange: EventEmitter<DefaultLangChangeEvent>;

An EventEmitter to listen to default lang change events onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => { // do something });

property onLangChange

onLangChange: EventEmitter<LangChangeEvent>;

An EventEmitter to listen to lang change events onLangChange.subscribe((params: LangChangeEvent) => { // do something });

property onTranslationChange

onTranslationChange: EventEmitter<TranslationChangeEvent>;

An EventEmitter to listen to translation change events onTranslationChange.subscribe((params: TranslationChangeEvent) => { // do something });

property translations

translations: Record<string, InterpolatableTranslationObject>;

a list of translations per lang

Interfaces

interface DefaultLangChangeEvent

interface DefaultLangChangeEvent {}

property lang

lang: string;

property translations

translations: InterpolatableTranslationObject;

interface InterpolatableTranslationObject

interface InterpolatableTranslationObject {}

index signature

[key: string]: InterpolatableTranslation;

interface LangChangeEvent

interface LangChangeEvent {}

property lang

lang: string;

property translations

translations: InterpolatableTranslationObject;

interface MissingTranslationHandlerParams

interface MissingTranslationHandlerParams {}

property interpolateParams

interpolateParams?: object;

interpolation params that were passed along for translating the given key.

property key

key: string;

the key that's missing in translation files

property translateService

translateService: TranslateService;

an instance of the service that was unable to translate the key.

interface TranslateModuleConfig

interface TranslateModuleConfig {}

property compiler

compiler?: Provider;

property defaultLanguage

defaultLanguage?: string;

property extend

extend?: boolean;

property isolate

isolate?: boolean;

property loader

loader?: Provider;

property missingTranslationHandler

missingTranslationHandler?: Provider;

property parser

parser?: Provider;

property useDefaultLang

useDefaultLang?: boolean;

interface TranslationChangeEvent

interface TranslationChangeEvent {}

property lang

lang: string;

property translations

translations: InterpolatableTranslationObject;

interface TranslationObject

interface TranslationObject {}

index signature

[key: string]: Translation;

Type Aliases

type InterpolatableTranslation

type InterpolatableTranslation =
    | string
    | InterpolatableTranslation[]
    | InterpolateFunction
    | InterpolatableTranslationObject
    | any;

type InterpolateFunction

type InterpolateFunction = (params?: InterpolationParameters) => string;

type InterpolationParameters

type InterpolationParameters = Record<string, any>;

type Language

type Language = string;

type Translation

type Translation = string | Translation[] | TranslationObject | any;

Package Files (11)

Dependencies (1)

tslib

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (2)

Badge

To add a badge like this oneto 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/@ngx-translate/core.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ngx-translate/core)

HTML

<a href="https://www.jsdocs.io/package/@ngx-translate/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 4 months ago.
Package analyzed in 4414 ms.
Missing or incorrect documentation? Open an issue for this package.

@ngx-translate/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable DEFAULT_LANGUAGE

variable ISOLATE_TRANSLATE_SERVICE

variable USE_DEFAULT_LANG

variable USE_EXTEND

Functions

function equals

Parameter o1

Parameter o2

Returns

function getValue

Parameter target

Parameter key

function isArray

function isDefined

function isDict

function isFunction

function isObject

function isString

function mergeDeep

function provideTranslateService

function setValue

Parameter target

Parameter key

Parameter value

Classes

class FakeMissingTranslationHandler

property ɵfac

property ɵprov

method handle

class MissingTranslationHandler

method handle

Parameter params

Returns

class TranslateCompiler

method compile

method compileTranslations

class TranslateDefaultParser

property ɵfac

property ɵprov

property templateMatcher

method interpolate

class TranslateDirective

constructor

property currentParams

property key

property lastParams

property onDefaultLangChangeSub

property onLangChangeSub

property onTranslationChangeSub

property ɵdir

property ɵfac

method checkNodes

method getContent

method ngAfterViewChecked

method ngOnDestroy

method setContent

method updateValue

class TranslateFakeCompiler

property ɵfac

property ɵprov

method compile

method compileTranslations

class TranslateFakeLoader

property ɵfac

property ɵprov

method getTranslation

class TranslateLoader

method getTranslation

class TranslateModule

property ɵfac