@ngx-translate/core

@ngx-translate/core

Version 17.0.0
Published 26 days ago
167 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 TRANSLATE_SERVICE_CONFIG

const TRANSLATE_SERVICE_CONFIG: InjectionToken<TranslateServiceConfig>;

Functions

function defaultProviders

defaultProviders: (
    config: RootTranslateServiceConfig | undefined,
    provideStore: boolean
) => Provider[];

function equals

equals: (o1: unknown, o2: unknown) => 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: unknown, key: string) => unknown;

Retrieves a value from a nested object using a dot-separated key path.
Example usage:
getValue({ key1: { keyA: 'valueI' }}, 'key1.keyA'); // returns 'valueI'
Parameter target
The source object from which to retrieve the value.
Parameter key
Dot-separated key path specifying the value to retrieve.
Returns
The value at the specified key path, or undefined if not found.

function insertValue

insertValue: <T>(target: Readonly<T>, key: string, value: unknown) => T;

Sets a value on object using a dot separated key. Returns a clone of the object without modifying it 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

function isArray

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

function isDefined

isDefined: <T>(value: T | null | undefined) => value is T;

function isDefinedAndNotNull

isDefinedAndNotNull: <T>(value: T | null | undefined) => value is T;

function isDict

isDict: (value: unknown) => value is InterpolatableTranslationObject;

function isFunction

isFunction: (value: unknown) => boolean;

function isObject

isObject: (value: unknown) => value is Record<string, unknown>;

function isString

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

function mergeDeep

mergeDeep: (target: Readonly<unknown>, source: Readonly<unknown>) => any;

function provideChildTranslateService

provideChildTranslateService: (
    config?: ChildTranslateServiceConfig
) => Provider[];

function provideMissingTranslationHandler

provideMissingTranslationHandler: (
    handler: Type<MissingTranslationHandler>
) => ClassProvider;

function provideTranslateCompiler

provideTranslateCompiler: (compiler: Type<TranslateCompiler>) => ClassProvider;

function provideTranslateLoader

provideTranslateLoader: (loader: Type<TranslateLoader>) => ClassProvider;

function provideTranslateParser

provideTranslateParser: (parser: Type<TranslateParser>) => ClassProvider;

function provideTranslateService

provideTranslateService: (config?: RootTranslateServiceConfig) => Provider[];

function setValue

setValue: (target: Record<string, unknown>, key: string, value: unknown) => void;

Sets a value on object using a dot separated key. This function modifies the object in place 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
Deprecated
use insertValue() instead

Classes

class DefaultMissingTranslationHandler

class DefaultMissingTranslationHandler 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<DefaultMissingTranslationHandler, never>;

property ɵprov

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

method handle

handle: (params: MissingTranslationHandlerParams) => string;

class ITranslateService

abstract class ITranslateService {}

property currentLang

abstract readonly currentLang: string;

Returns the current language
Deprecated
use getCurrentLang()

property defaultLang

abstract readonly defaultLang: string;

Returns the fallback language use getFallbackLang()

property langs

abstract readonly langs: readonly string[];

Returns a list of known languages - either loaded or set by using addLangs()
Deprecated
use getLangs()

property onDefaultLangChange

abstract readonly onDefaultLangChange: Observable<FallbackLangChangeEvent>;

use getFallbackLang()

property onFallbackLangChange

abstract readonly onFallbackLangChange: Observable<FallbackLangChangeEvent>;

property onLangChange

abstract readonly onLangChange: Observable<LangChangeEvent>;

property onTranslationChange

abstract readonly onTranslationChange: Observable<TranslationChangeEvent>;

method addLangs

abstract addLangs: (languages: Language[]) => void;

method get

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

method getBrowserCultureLang

abstract getBrowserCultureLang: () => Language | undefined;

method getBrowserLang

abstract getBrowserLang: () => Language | undefined;

method getDefaultLang

abstract getDefaultLang: () => Language | null;

Gets the fallback language
Deprecated
use getFallbackLang()

method getFallbackLang

abstract getFallbackLang: () => Language | null;

method getLangs

abstract getLangs: () => readonly Language[];

method getParsedResult

abstract getParsedResult: (
    key: string | string[],
    interpolateParams?: InterpolationParameters
) => StrictTranslation | Observable<StrictTranslation>;

method getStreamOnTranslationChange

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

method instant

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

method reloadLang

abstract reloadLang: (
    lang: Language
) => Observable<InterpolatableTranslationObject>;

method resetLang

abstract resetLang: (lang: Language) => void;

method set

abstract set: (
    key: string,
    translation: string | TranslationObject,
    lang?: Language
) => void;

method setDefaultLang

abstract setDefaultLang: (
    lang: Language
) => Observable<InterpolatableTranslationObject>;

Sets the fallback language
Parameter lang
The language to set
Deprecated
use setFallbackLang(lang)

method setFallbackLang

abstract setFallbackLang: (
    lang: Language
) => Observable<InterpolatableTranslationObject>;

method setTranslation

abstract setTranslation: (
    lang: Language,
    translations: TranslationObject,
    shouldMerge?: boolean
) => void;

method stream

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

method use

abstract use: (lang: Language) => Observable<InterpolatableTranslationObject>;

class MissingTranslationHandler

abstract class MissingTranslationHandler {}

method handle

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

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: TranslationObject,
    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 formatValue

protected formatValue: (value: unknown) => string | undefined;

Converts a value into a useful string representation.
Parameter value
The value to format.
Returns
A string representation of the value.

method getInterpolationReplacement

protected getInterpolationReplacement: (
    params: InterpolationParameters,
    key: string
) => string | undefined;

Returns the replacement for an interpolation parameter @params:

method interpolate

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

method interpolateFunction

protected interpolateFunction: (
    fn: InterpolateFunction,
    params?: InterpolationParameters
) => string;

method interpolateString

protected interpolateString: (
    expr: string,
    params?: InterpolationParameters
) => string;

class TranslateDirective

class TranslateDirective implements AfterViewChecked, OnDestroy {}

constructor

constructor();

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 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 TranslatePipe, typeof TranslateDirective],
    [typeof TranslatePipe, typeof 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 TranslateNoOpCompiler

class TranslateNoOpCompiler 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<TranslateNoOpCompiler, never>;

property ɵprov

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

method compile

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

method compileTranslations

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

class TranslateNoOpLoader

class TranslateNoOpLoader 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<TranslateNoOpLoader, never>;

property ɵprov

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

method getTranslation

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

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 {}

property lastKey

lastKey: string;

property lastParams

lastParams: InterpolationParameters[];

property onFallbackLangChange

onFallbackLangChange: 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>;

method ngOnDestroy

ngOnDestroy: () => void;

method transform

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

method updateValue

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

class TranslateService

class TranslateService implements ITranslateService {}

constructor

constructor();

property compiler

compiler: TranslateCompiler;

property currentLang

readonly currentLang: string;

The lang currently used
Deprecated
use getCurrentLang()

property currentLoader

currentLoader: TranslateLoader;

property defaultLang

readonly defaultLang: string;

Deprecated
use getFallbackLang()

property langs

readonly langs: readonly string[];

Deprecated
use getLangs()

property onDefaultLangChange

readonly onDefaultLangChange: Observable<FallbackLangChangeEvent>;

Deprecated
Use onFallbackLangChange() instead

property onFallbackLangChange

readonly onFallbackLangChange: Observable<FallbackLangChangeEvent>;

An Observable to listen to fallback lang change events onFallbackLangChange.subscribe((params: FallbackLangChangeEvent) => { // do something });

property onLangChange

readonly onLangChange: Observable<LangChangeEvent>;

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

property onTranslationChange

readonly onTranslationChange: Observable<TranslationChangeEvent>;

An Observable 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>;

method addLangs

addLangs: (languages: Language[]) => 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

static getBrowserCultureLang: () => Language | undefined;

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

method getBrowserLang

static getBrowserLang: () => Language | undefined;

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

method getCurrentLang

getCurrentLang: () => Language;

method getDefaultLang

getDefaultLang: () => Language | null;

Gets the fallback language used
Deprecated
use getFallbackLang()

method getFallbackLang

getFallbackLang: () => Language | null;

Gets the fallback language. null if none is defined

method getLangs

getLangs: () => readonly Language[];

method getParsedResult

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

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 instant

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

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: Language) => Observable<InterpolatableTranslationObject>;

Allows reloading the lang file from the file

method resetLang

resetLang: (lang: Language) => void;

Deletes inner translation

method set

set: (
    key: string,
    translation: string | TranslationObject,
    lang?: Language
) => void;

Sets the translated value of a key, after compiling it

method setDefaultLang

setDefaultLang: (lang: Language) => Observable<InterpolatableTranslationObject>;

Sets the language to use as a fallback
Deprecated
use setFallbackLanguage()

method setFallbackLang

setFallbackLang: (lang: Language) => Observable<InterpolatableTranslationObject>;

Sets the fallback language to use if a translation is not found in the current language

method setTranslation

setTranslation: (
    lang: Language,
    translations: TranslationObject,
    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: Language) => Observable<InterpolatableTranslationObject>;

Changes the lang currently used

class TranslateStore

class TranslateStore {}

property onFallbackLangChange

readonly onFallbackLangChange: Observable<FallbackLangChangeEvent>;

An Observable to listen to fallback lang change events onFallbackLangChange.subscribe((params: FallbackLangChangeEvent) => { // do something });

property onLangChange

readonly onLangChange: Observable<LangChangeEvent>;

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

property onTranslationChange

readonly onTranslationChange: Observable<TranslationChangeEvent>;

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

property ɵfac

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

property ɵprov

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

method addLanguages

addLanguages: (languages: Language[]) => void;

method deleteTranslations

deleteTranslations: (lang: string) => void;

method getCurrentLang

getCurrentLang: () => Language;

method getFallbackLang

getFallbackLang: () => Language | null;

method getLanguages

getLanguages: () => readonly Language[];

method getTranslation

getTranslation: (key: string) => InterpolatableTranslation;

method getTranslations

getTranslations: (
    language: Language
) => DeepReadonly<InterpolatableTranslationObject>;

method getValue

protected getValue: (
    language: Language,
    key: string
) => InterpolatableTranslation;

method hasTranslationFor

hasTranslationFor: (lang: string) => boolean;

method setCurrentLang

setCurrentLang: (lang: string, emitChange?: boolean) => void;

method setFallbackLang

setFallbackLang: (lang: string, emitChange?: boolean) => void;

Changes the fallback lang

method setTranslations

setTranslations: (
    language: Language,
    translations: InterpolatableTranslationObject,
    extend: boolean
) => void;

Interfaces

interface ChildTranslateServiceConfig

interface ChildTranslateServiceConfig extends Partial<TranslateProviders> {}

property extend

extend?: boolean;

interface FallbackLangChangeEvent

interface FallbackLangChangeEvent {}

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 RootTranslateServiceConfig

interface RootTranslateServiceConfig extends ChildTranslateServiceConfig {}

property defaultLanguage

defaultLanguage?: Language;

property fallbackLang

fallbackLang?: Language;

property lang

lang?: Language;

property useDefaultLang

useDefaultLang?: boolean;

interface TranslateModuleConfig

interface TranslateModuleConfig extends TranslateProviders {}

property defaultLanguage

defaultLanguage?: string;

Deprecated
use fallbackLang

property extend

extend?: boolean;

property fallbackLang

fallbackLang?: Language;

property isolate

isolate?: boolean;

property lang

lang?: Language;

property useDefaultLang

useDefaultLang?: boolean;

Deprecated
use fallbackLang

interface TranslateProviders

interface TranslateProviders {}

property compiler

compiler?: Provider;

property loader

loader?: Provider;

property missingTranslationHandler

missingTranslationHandler?: Provider;

property parser

parser?: Provider;

interface TranslateServiceConfig

interface TranslateServiceConfig {}

Configuration object for the translation service.
Provides options to customize translation behavior, including setting the primary language, specifying a fallback language, and other deprecated flags for legacy support.

property extend

extend: boolean;

property fallbackLang

fallbackLang?: Language | null;

property lang

lang?: Language;

interface TranslationChangeEvent

interface TranslationChangeEvent {}

property lang

lang: string;

property translations

translations: InterpolatableTranslationObject;

interface TranslationObject

interface TranslationObject {}

index signature

[key: string]: StrictTranslation;

Type Aliases

type DeepReadonly

type DeepReadonly<T> = {
    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

type DefaultLangChangeEvent

type DefaultLangChangeEvent = FallbackLangChangeEvent;

Deprecated
use FallbackLangChangeEvent

type InterpolatableTranslation

type InterpolatableTranslation =
    | string
    | InterpolatableTranslation[]
    | InterpolateFunction
    | InterpolatableTranslationObject
    | undefined
    | null;

type InterpolateFunction

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

type InterpolationParameters

type InterpolationParameters = Record<string, any>;

type Language

type Language = string;

type StrictTranslation

type StrictTranslation =
    | string
    | StrictTranslation[]
    | TranslationObject
    | undefined
    | null;

type Translation

type Translation = StrictTranslation | any;

Package Files (1)

index.d.ts

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 26 days ago.
Package analyzed in 5879 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 TRANSLATE_SERVICE_CONFIG

Functions

function defaultProviders

function equals

Parameter o1

Parameter o2

Returns

function getValue

Parameter target

Parameter key

Returns

function insertValue

Parameter target

Parameter key

Parameter value

function isArray

function isDefined

function isDefinedAndNotNull

function isDict

function isFunction

function isObject

function isString

function mergeDeep

function provideChildTranslateService

function provideMissingTranslationHandler

function provideTranslateCompiler

function provideTranslateLoader

function provideTranslateParser

function provideTranslateService

function setValue

Parameter target

Parameter key

Parameter value

Deprecated

Classes

class DefaultMissingTranslationHandler

property ɵfac

property ɵprov

method handle

class ITranslateService

property currentLang

Deprecated

property defaultLang

property langs

Deprecated

property onDefaultLangChange

property onFallbackLangChange

property onLangChange

property onTranslationChange

method addLangs

method get

method getBrowserCultureLang

method getBrowserLang

method getDefaultLang

Deprecated

method getFallbackLang

method getLangs

method getParsedResult

method getStreamOnTranslationChange

method instant

method reloadLang

method resetLang

method set

method setDefaultLang

Parameter lang

Deprecated

method setFallbackLang

method setTranslation

method stream

method use