@tolgee/core 4.9.2 → 5.0.0-rc.0b3e627.0

package/lib/Controller/Cache/Cache.d.ts

@@ -0,0 +1,23 @@
+import { CacheDescriptor, CacheDescriptorInternal, CacheDescriptorWithKey, EventEmitterType, FallbackNSTranslation, Options, TranslationsFlat, TranslationValue, TreeTranslationsData, BackendGetRecord, BackendGetDevRecord } from '../../types';
+import { ValueObserverInstance } from '../ValueObserver';
+export declare const Cache: (onCacheChange: EventEmitterType<CacheDescriptorWithKey>, backendGetRecord: BackendGetRecord, backendGetDevRecord: BackendGetDevRecord, withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal, isInitialLoading: () => boolean, fetchingObserver: ValueObserverInstance<boolean>, loadingObserver: ValueObserverInstance<boolean>) => Readonly<{
+    addStaticData: (data: Options['staticData']) => void;
+    invalidate: () => void;
+    addRecord: (descriptor: CacheDescriptorInternal, data: TreeTranslationsData) => void;
+    exists: (descriptor: CacheDescriptorInternal, strict?: boolean) => boolean;
+    getRecord: (descriptor: CacheDescriptorInternal) => TranslationsFlat | undefined;
+    getTranslation: (descriptor: CacheDescriptorInternal, key: string) => TranslationValue;
+    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string | string[];
+    getTranslationFallback: (namespaces: string[], languages: string[], key: string) => string | undefined;
+    changeTranslation: (descriptor: CacheDescriptorInternal, key: string, value: TranslationValue) => void;
+    isFetching: (ns?: FallbackNSTranslation) => boolean;
+    isLoading: (language: string | undefined, ns?: FallbackNSTranslation) => boolean;
+    loadRecords: (descriptors: CacheDescriptor[], isDev: boolean) => Promise<TranslationsFlat[]>;
+    clear: () => void;
+    getAllRecords: () => {
+        data: TranslationsFlat;
+        language: string;
+        namespace: string;
+    }[];
+}>;
+export declare type CacheType = ReturnType<typeof Cache>;

package/lib/Controller/Cache/helpers.d.ts

@@ -0,0 +1,4 @@
+import { CacheDescriptorInternal, TreeTranslationsData } from '../../types';
+export declare const flattenTranslations: (data: TreeTranslationsData) => Map<string, string>;
+export declare const decodeCacheKey: (key: string) => CacheDescriptorInternal;
+export declare const encodeCacheKey: ({ language, namespace, }: CacheDescriptorInternal) => string;

package/lib/Controller/Controller.d.ts

@@ -0,0 +1,93 @@
+import type { EventServiceType } from '../Events/Events';
+import { CacheDescriptor, FallbackNSTranslation, Options, TFnType, TranslatePropsInternal } from '../types';
+declare type StateServiceProps = {
+    events: EventServiceType;
+    options?: Partial<Options>;
+};
+export declare const Controller: ({ events, options }: StateServiceProps) => Readonly<{
+    init: (options: Partial<Options>) => void;
+    changeLanguage: (language: string) => Promise<void>;
+    getTranslation: ({ key, ns, }: Pick<TranslatePropsInternal, 'key' | 'ns'>) => string | undefined;
+    changeTranslation: (descriptor: CacheDescriptor, key: string, value: string) => {
+        revert: () => void;
+    };
+    addActiveNs: (ns: FallbackNSTranslation, forget?: boolean) => Promise<void>;
+    loadRequiredRecords: (lang?: string, ns?: FallbackNSTranslation) => void | Promise<void>;
+    loadRecords: (descriptors: CacheDescriptor[]) => Promise<import("../types").TranslationsFlat[]>;
+    loadRecord: (descriptor: CacheDescriptor) => Promise<import("../types").TranslationsFlat>;
+    isLoading: (ns?: FallbackNSTranslation) => boolean;
+    isLoaded: (ns?: FallbackNSTranslation) => boolean;
+    t: TFnType<import("../types").DefaultParamType, string>;
+    isDev: () => boolean;
+    run: () => Promise<void | undefined>;
+    stop: () => void;
+    addStaticData: (data: {
+        [key: string]: import("../types").TreeTranslationsData | (() => Promise<import("../types").TreeTranslationsData>);
+    } | undefined) => void;
+    invalidate: () => void;
+    addRecord: (descriptor: import("../types").CacheDescriptorInternal, data: import("../types").TreeTranslationsData) => void;
+    exists: (descriptor: import("../types").CacheDescriptorInternal, strict?: boolean) => boolean;
+    getRecord: (descriptor: import("../types").CacheDescriptorInternal) => import("../types").TranslationsFlat | undefined;
+    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string | string[];
+    getTranslationFallback: (namespaces: string[], languages: string[], key: string) => string | undefined;
+    isFetching: (ns?: FallbackNSTranslation) => boolean;
+    clear: () => void;
+    getAllRecords: () => {
+        data: import("../types").TranslationsFlat;
+        language: string;
+        namespace: string;
+    }[];
+    setFinalFormatter: (formatter: import("../types").FinalFormatterInterface | undefined) => void;
+    addFormatter: (formatter: import("../types").FormatterInterface | undefined) => void;
+    formatTranslation: ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }: {
+        key: string;
+        defaultValue?: string | undefined;
+    } & import("../types").TranslateOptions<import("../types").DefaultParamType> & {
+        translation?: string | undefined;
+    } & {
+        formatEnabled?: boolean | undefined;
+    }) => string;
+    setObserver: (observer: import("../types").ObserverInterface | undefined) => void;
+    getObserver: () => {
+        unwrap: (text: string) => import("../types").Unwrapped;
+        wrap: import("../types").WrapperWrapFunction;
+        retranslate: () => void;
+        stop: () => void;
+        run: (props: import("../types").ObserverRunProps) => void;
+        highlight: import("../types").HighlightInterface;
+        outputNotFormattable: boolean;
+    } | undefined;
+    setUi: (ui: import("../types").UiType | undefined) => void;
+    getUi: () => import("../types").UiConstructor | undefined;
+    addBackend: (backend: import("../types").BackendInterface | undefined) => void;
+    setDevBackend: (backend: import("../types").BackendDevInterface | undefined) => void;
+    getDevBackend: () => import("../types").BackendDevInterface | undefined;
+    getBackendRecord: import("../types").BackendGetRecord;
+    getBackendDevRecord: import("../types").BackendGetRecord;
+    setLanguageDetector: (detector: import("../types").LanguageDetectorInterface | undefined) => void;
+    setLanguageStorage: (storage: import("../types").LanguageStorageInterface | undefined) => void;
+    getInitialLanguage: () => string | Promise<string | undefined> | Promise<string | Promise<string | undefined> | undefined> | undefined;
+    setStoredLanguage: (language: string) => void;
+    retranslate: () => void;
+    highlight: import("../types").HighlightInterface;
+    wrap: (params: import("../types").WrapperWrapProps) => string | undefined;
+    unwrap: (text: string) => import("../types").Unwrapped;
+    isRunning: () => boolean;
+    setRunning: (value: boolean) => void;
+    isInitialLoading: () => boolean;
+    setInitialLoading: (value: boolean) => void;
+    getLanguage: () => string | undefined;
+    getLanguageOrFail: () => string;
+    setLanguage: (language: string) => void;
+    getPendingLanguage: () => string | undefined;
+    setPendingLanguage: (language: string) => void;
+    getInitialOptions: () => Options;
+    removeActiveNs: (ns: FallbackNSTranslation) => void;
+    getRequiredNamespaces: () => string[];
+    getFallbackLangs: (lang?: string | undefined) => string[];
+    getFallbackNamespaces: () => string[];
+    getAvailableLanguages: () => string[] | undefined;
+    withDefaultNs: (descriptor: CacheDescriptor) => import("../types").CacheDescriptorInternal;
+}>;
+export declare type StateServiceType = ReturnType<typeof Controller>;
+export {};

package/lib/Controller/Plugins/Plugins.d.ts

@@ -0,0 +1,41 @@
+import { BackendDevInterface, BackendGetRecord, BackendInterface, FormatterInterface, ObserverInterface, TranslatePropsInternal, UiType, FinalFormatterInterface, HighlightInterface, UiConstructor, LanguageDetectorInterface, LanguageStorageInterface, Options, ChangeTranslationInterface, WrapperWrapProps, Unwrapped } from '../../types';
+export declare const PluginService: (getLanguage: () => string | undefined, getInitialOptions: () => Options, getAvailableLanguages: () => string[] | undefined, getTranslationNs: (props: TranslatePropsInternal) => string[] | string, getTranslation: (props: TranslatePropsInternal) => string | undefined, changeTranslation: ChangeTranslationInterface) => Readonly<{
+    setFinalFormatter: (formatter: FinalFormatterInterface | undefined) => void;
+    addFormatter: (formatter: FormatterInterface | undefined) => void;
+    formatTranslation: ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }: {
+        key: string;
+        defaultValue?: string | undefined;
+    } & import("../../types").TranslateOptions<import("../../types").DefaultParamType> & {
+        translation?: string | undefined;
+    } & {
+        formatEnabled?: boolean | undefined;
+    }) => string;
+    setObserver: (observer: ObserverInterface | undefined) => void;
+    getObserver: () => {
+        unwrap: (text: string) => Unwrapped;
+        wrap: import("../../types").WrapperWrapFunction;
+        retranslate: () => void;
+        stop: () => void;
+        run: (props: import("../../types").ObserverRunProps) => void;
+        highlight: HighlightInterface;
+        outputNotFormattable: boolean;
+    } | undefined;
+    setUi: (ui: UiType | undefined) => void;
+    getUi: () => UiConstructor | undefined;
+    addBackend: (backend: BackendInterface | undefined) => void;
+    setDevBackend: (backend: BackendDevInterface | undefined) => void;
+    getDevBackend: () => BackendDevInterface | undefined;
+    getBackendRecord: BackendGetRecord;
+    getBackendDevRecord: BackendGetRecord;
+    setLanguageDetector: (detector: LanguageDetectorInterface | undefined) => void;
+    setLanguageStorage: (storage: LanguageStorageInterface | undefined) => void;
+    getInitialLanguage: () => string | Promise<string | undefined> | Promise<string | Promise<string | undefined> | undefined> | undefined;
+    setStoredLanguage: (language: string) => void;
+    run: () => void;
+    stop: () => void;
+    retranslate: () => void;
+    highlight: HighlightInterface;
+    wrap: (params: WrapperWrapProps) => string | undefined;
+    unwrap: (text: string) => Unwrapped;
+}>;
+export declare type PluginServiceType = ReturnType<typeof PluginService>;

package/lib/Controller/State/State.d.ts

@@ -0,0 +1,22 @@
+import { CacheDescriptor, CacheDescriptorInternal, EventEmitterType, FallbackNSTranslation } from '../../types';
+import { Options } from './initState';
+export declare const State: (onLanguageChange: EventEmitterType<string>, onPendingLanguageChange: EventEmitterType<string>, onRunningChange: EventEmitterType<boolean>) => Readonly<{
+    init: (options?: Partial<Options>) => void;
+    isRunning: () => boolean;
+    setRunning: (value: boolean) => void;
+    isInitialLoading: () => boolean;
+    setInitialLoading: (value: boolean) => void;
+    getLanguage: () => string | undefined;
+    getLanguageOrFail: () => string;
+    setLanguage: (language: string) => void;
+    getPendingLanguage: () => string | undefined;
+    setPendingLanguage: (language: string) => void;
+    getInitialOptions: () => Options;
+    addActiveNs: (ns: FallbackNSTranslation) => void;
+    removeActiveNs: (ns: FallbackNSTranslation) => void;
+    getRequiredNamespaces: () => string[];
+    getFallbackLangs: (lang?: string) => string[];
+    getFallbackNamespaces: () => string[];
+    getAvailableLanguages: () => string[] | undefined;
+    withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal;
+}>;

package/lib/Controller/State/helpers.d.ts

@@ -0,0 +1,6 @@
+import { FallbackGeneral, FallbackLanguageOption } from '../../types';
+export declare function isObject(item: any): boolean;
+export declare function getFallback(value: FallbackGeneral): string[] | undefined;
+export declare function getFallbackArray(value: FallbackGeneral): string[];
+export declare function getFallbackFromStruct(language: string, fallbackLanguage: FallbackLanguageOption): string[];
+export declare function unique<T>(arr: T[]): T[];

package/lib/Controller/State/initState.d.ts

@@ -0,0 +1,55 @@
+import { FallbackLanguageOption, FallbackNS, TreeTranslationsData } from '../../types';
+export declare type Options = {
+    /**
+     * Initial language
+     */
+    language?: string;
+    apiUrl?: string;
+    apiKey?: string;
+    projectId?: number;
+    /**
+     * Used when auto detection is not available or is turned off
+     */
+    defaultLanguage?: string;
+    /**
+     * Languages which can be used for language detection
+     * and also limits which values can be stored
+     */
+    availableLanguages?: string[];
+    /**
+     * Language which is used when no translation is available for current one
+     */
+    fallbackLanguage?: FallbackLanguageOption;
+    /**
+     * Store user language in localStorage (default: true)
+     */
+    enableLanguageStore?: boolean;
+    /**
+     * Namespaces which should be always fetched
+     */
+    ns?: string[];
+    /**
+     * Namespaces to be used to find translation when no explicit namespace set.
+     */
+    fallbackNs?: FallbackNS;
+    /**
+     * Default namespace when no namespace defined (default: '')
+     */
+    defaultNs: string;
+    /**
+     * Prefix used for fetching languages (default: 'i18n/')
+     */
+    filesUrlPrefix: string;
+    staticData?: {
+        [key: string]: TreeTranslationsData | (() => Promise<TreeTranslationsData>);
+    };
+};
+export declare type State = {
+    initialOptions: Options;
+    activeNamespaces: Map<string, number>;
+    language: string | undefined;
+    pendingLanguage: string | undefined;
+    isInitialLoading: boolean;
+    isRunning: boolean;
+};
+export declare const initState: (options?: Partial<Options>, previousState?: State) => State;

package/lib/Controller/ValueObserver.d.ts

@@ -0,0 +1,5 @@
+export declare const ValueObserver: <T = any>(initialValue: T, valueGetter: () => T, handler: (value: T) => void) => Readonly<{
+    init: (value: T) => void;
+    notify: () => void;
+}>;
+export declare type ValueObserverInstance<T> = ReturnType<typeof ValueObserver<T>>;

package/lib/Events/EventEmitter.d.ts

@@ -0,0 +1,6 @@
+import { Listener, ListenerHandler } from '../types';
+export declare const EventEmitter: <T>() => Readonly<{
+    listen: (handler: ListenerHandler<T>) => Listener;
+    emit: (data: T) => void;
+}>;
+export declare type EventEmitterType<T> = ReturnType<typeof EventEmitter<T>>;

package/lib/Events/EventEmitterSelective.d.ts

@@ -0,0 +1,15 @@
+import { FallbackNSTranslation, KeyDescriptor, KeyDescriptorInternal, ListenerHandler } from '../types';
+export declare const EventEmitterSelective: <T>() => Readonly<{
+    listenSome: (handler: ListenerHandler<undefined>) => {
+        unsubscribe: () => void;
+        subscribeNs: (ns: FallbackNSTranslation) => any;
+        unsubscribeNs: (ns: FallbackNSTranslation) => any;
+        subscribeKey: (descriptor: KeyDescriptor) => any;
+        unsubscribeKey: (descriptor: KeyDescriptor) => any;
+    };
+    listen: (handler: ListenerHandler<T>) => {
+        unsubscribe: () => void;
+    };
+    emit: (descriptor?: KeyDescriptorInternal, delayed?: boolean) => void;
+}>;
+export declare type EventEmitterSelectiveType<T> = ReturnType<typeof EventEmitterSelective<T>>;

package/lib/Events/Events.d.ts

@@ -0,0 +1,50 @@
+import { CacheDescriptorWithKey, KeyDescriptorInternal, ListenerHandler, TolgeeOn } from '../types';
+export declare const Events: () => Readonly<{
+    onPendingLanguageChange: Readonly<{
+        listen: (handler: ListenerHandler<string>) => import("../types").Listener;
+        emit: (data: string) => void;
+    }>;
+    onLanguageChange: Readonly<{
+        listen: (handler: ListenerHandler<string>) => import("../types").Listener;
+        emit: (data: string) => void;
+    }>;
+    onKeyChange: Readonly<{
+        listen: (handler: ListenerHandler<KeyDescriptorInternal>) => import("../types").Listener;
+        emit: (data: KeyDescriptorInternal) => void;
+    }>;
+    onKeyUpdate: Readonly<{
+        listenSome: (handler: ListenerHandler<undefined>) => {
+            unsubscribe: () => void;
+            subscribeNs: (ns: import("../types").FallbackNSTranslation) => any;
+            unsubscribeNs: (ns: import("../types").FallbackNSTranslation) => any;
+            subscribeKey: (descriptor: import("../types").KeyDescriptor) => any;
+            unsubscribeKey: (descriptor: import("../types").KeyDescriptor) => any;
+        };
+        listen: (handler: ListenerHandler<void>) => {
+            unsubscribe: () => void;
+        };
+        emit: (descriptor?: KeyDescriptorInternal | undefined, delayed?: boolean | undefined) => void;
+    }>;
+    onLoadingChange: Readonly<{
+        listen: (handler: ListenerHandler<boolean>) => import("../types").Listener;
+        emit: (data: boolean) => void;
+    }>;
+    onFetchingChange: Readonly<{
+        listen: (handler: ListenerHandler<boolean>) => import("../types").Listener;
+        emit: (data: boolean) => void;
+    }>;
+    onInitialLoaded: Readonly<{
+        listen: (handler: ListenerHandler<void>) => import("../types").Listener;
+        emit: (data: void) => void;
+    }>;
+    onRunningChange: Readonly<{
+        listen: (handler: ListenerHandler<boolean>) => import("../types").Listener;
+        emit: (data: boolean) => void;
+    }>;
+    onCacheChange: Readonly<{
+        listen: (handler: ListenerHandler<CacheDescriptorWithKey>) => import("../types").Listener;
+        emit: (data: CacheDescriptorWithKey) => void;
+    }>;
+    on: TolgeeOn;
+}>;
+export declare type EventServiceType = ReturnType<typeof Events>;

package/lib/Tolgee.d.ts

@@ -1,68 +1,2 @@
-import { TolgeeConfig } from './TolgeeConfig';
-import { InstantProps, InstantPropsTags, TolgeeModule, TranslateProps, TranslatePropsTags, TranslationTags, TranslationParams, TranslationParamsTags } from './types';
-export declare class Tolgee {
-    private dependencyService;
-    private constructor();
-    get properties(): import("./Properties").Properties;
-    get lang(): string;
-    /**
-     * This sets a new language.
-     *
-     * Using this setter can behave buggy when you change languages
-     * too fast, since it changes the language property before
-     * translations are actually loaded.
-     * @deprecated use asynchronous changeLanguage method.
-     */
-    set lang(newLanguage: string);
-    get defaultLanguage(): string;
-    get onLangChange(): import("./services/EventEmitter").EventEmitter<string>;
-    get onTranslationChange(): import("./services/EventEmitter").EventEmitter<import(".").TranslationData>;
-    /**
-     * Is emitted when language is loaded for the first time
-     */
-    get onLangLoaded(): import("./services/EventEmitter").EventEmitter<string>;
-    /**
-     * True if loading is needed to wait for Tolgee init.
-     * When translation data are provided statically (using import
-     * as staticData config property) then there is no need for translation
-     * fetching so initial loading is not needed at all.
-     */
-    get initialLoading(): boolean;
-    private get coreService();
-    static use(module: TolgeeModule): Tolgee;
-    static init(config: TolgeeConfig): Tolgee;
-    /**
-     * Sets the new language.
-     *
-     * Emits the onLangChange and onLangChangeAndLoad events after
-     * the translations are loaded.
-     *
-     * @return Promise<void> Resolves when translations are loaded
-     */
-    changeLanguage(newLanguage: string): Promise<void>;
-    use(module: TolgeeModule): this;
-    init(config: TolgeeConfig): this;
-    run(): Promise<void>;
-    refresh(): Promise<void>;
-    translate(props: TranslateProps): Promise<string>;
-    translate<T>(props: TranslatePropsTags<T>): Promise<TranslationTags<T>>;
-    translate(key: string, params?: TranslationParams, noWrap?: boolean, defaultValue?: string): Promise<string>;
-    translate<T>(key: string, params?: TranslationParamsTags<T>, noWrap?: boolean, defaultValue?: string): Promise<TranslationTags<T>>;
-    wrap(key: string, params?: TranslationParams, defaultValue?: string | undefined, translation?: string): string;
-    wrap<T>(key: string, params?: TranslationTags<T>, defaultValue?: string | undefined, translation?: TranslationTags<T>): TranslationTags<T>;
-    instant(key: string, params?: TranslationParams, noWrap?: boolean, orEmpty?: boolean, defaultValue?: string): string;
-    instant<T>(key: string, params?: TranslationParamsTags<T>, noWrap?: boolean, orEmpty?: boolean, defaultValue?: string): TranslationTags<T>;
-    instant(props: InstantProps): string;
-    instant<T>(props: InstantPropsTags<T>): TranslationTags<T>;
-    /**
-     * Get currently cached translations for all languages
-     */
-    getCachedTranslations(): Map<string, import("./types").Translations>;
-    /**
-     * Loads translations for given language or returns them from cache
-     * @returns Loaded translations
-     */
-    loadTranslations(lang: string): Promise<import("./types").Translations>;
-    stop: () => void;
-    private emitLangChangeEvent;
-}
+import { Options, TolgeeInstance } from './types';
+export declare const Tolgee: (options?: Partial<Options>) => TolgeeInstance;

package/lib/TranslateParams.d.ts

@@ -0,0 +1,2 @@
+import { TFnType, TranslateProps } from './types';
+export declare const getTranslateParams: TFnType<any, TranslateProps<any>>;

package/lib/{Constants/Global.d.ts → constants.d.ts}

@@ -1,6 +1,5 @@
 export declare const RESTRICTED_ASCENDANT_ATTRIBUTE = "data-tolgee-restricted";
 export declare const TOLGEE_ATTRIBUTE_NAME = "_tolgee";
-export declare const TOLGEE_TARGET_ATTRIBUTE = "_tolgee-target";
-export declare const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = "data-tolgee-key-only";
 export declare const TOLGEE_HIGHLIGHTER_CLASS = "_tolgee-highlighter";
+export declare const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = "data-tolgee-key-only";
 export declare const DEVTOOLS_ID = "__tolgee_dev_tools";

package/lib/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function isPromise(value: any): boolean;
+export declare const valueOrPromise: <T, R>(value: T | Promise<T>, callback: (value: T) => R) => R | Promise<R>;
+export declare const missingOptionError: (option: string) => string;

package/lib/index.d.ts

@@ -1,10 +1,5 @@
 export { Tolgee } from './Tolgee';
-export { TolgeeConfig } from './TolgeeConfig';
-export { ModifierKey } from './Constants/ModifierKey';
-export { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from './Constants/Global';
-export * from './modules';
-export * from './types/DTOs';
+export { RESTRICTED_ASCENDANT_ATTRIBUTE, DEVTOOLS_ID, TOLGEE_ATTRIBUTE_NAME, TOLGEE_HIGHLIGHTER_CLASS, TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE, } from './constants';
 export * from './types';
-export * from './Constants/Global';
-export * from './helpers/NodeHelper';
-export * from './helpers/TextHelper';
+export { getTranslateParams } from './TranslateParams';
+export { getFallback, getFallbackArray } from './Controller/State/helpers';