@tolgee/core 4.9.2 → 4.9.3-rc.128edeb.0

package/dist/tolgee.esm.js

@@ -0,0 +1,1404 @@
+const EventEmitter = () => {
+    let handlers = [];
+    const listen = (handler) => {
+        const handlerWrapper = (e) => {
+            handler(e);
+        };
+        handlers.push(handlerWrapper);
+        return {
+            unsubscribe: () => {
+                handlers = handlers.filter((i) => handlerWrapper !== i);
+            },
+        };
+    };
+    const emit = (data) => {
+        handlers.forEach((handler) => handler({ value: data }));
+    };
+    return Object.freeze({ listen, emit });
+};
+
+function isObject(item) {
+    return typeof item === 'object' && !Array.isArray(item) && item !== null;
+}
+function getFallback(value) {
+    if (typeof value === 'string') {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function getFallbackArray(value) {
+    return getFallback(value) || [];
+}
+function getFallbackFromStruct(language, fallbackLanguage) {
+    if (isObject(fallbackLanguage)) {
+        return getFallbackArray(fallbackLanguage === null || fallbackLanguage === void 0 ? void 0 : fallbackLanguage[language]);
+    }
+    else {
+        return getFallbackArray(fallbackLanguage);
+    }
+}
+function unique(arr) {
+    return Array.from(new Set(arr));
+}
+
+function incrementInMap(map, value) {
+    const currNum = map.get(value) || 0;
+    map.set(value, currNum + 1);
+}
+function decrementInMap(map, value) {
+    let currNum = map.get(value) || 1;
+    currNum -= 1;
+    if (currNum <= 0) {
+        map.delete(value);
+    }
+    else {
+        map.set(value, currNum);
+    }
+}
+const EventEmitterSelective = (getFallbackNamespaces) => {
+    const listeners = new Set();
+    const partialListeners = new Set();
+    const listen = (handler) => {
+        listeners.add(handler);
+        const result = {
+            unsubscribe: () => {
+                listeners.delete(handler);
+            },
+        };
+        return result;
+    };
+    const listenSome = (handler) => {
+        const handlerWrapper = {
+            fn: (e) => {
+                handler(e);
+            },
+            keys: new Map(),
+            namespaces: new Map(),
+        };
+        partialListeners.add(handlerWrapper);
+        const result = {
+            unsubscribe: () => {
+                partialListeners.delete(handlerWrapper);
+            },
+            subscribeNs: (ns) => {
+                getFallbackArray(ns).forEach((val) => incrementInMap(handlerWrapper.namespaces, val));
+                return result;
+            },
+            unsubscribeNs: (ns) => {
+                getFallbackArray(ns).forEach((val) => decrementInMap(handlerWrapper.namespaces, val));
+                return result;
+            },
+            subscribeKey: (descriptor) => {
+                const { key, ns } = descriptor;
+                incrementInMap(handlerWrapper.keys, key);
+                getFallbackArray(ns).forEach((val) => incrementInMap(handlerWrapper.namespaces, val));
+                if (ns === undefined) {
+                    // subscribing to all namespaces
+                    incrementInMap(handlerWrapper.namespaces, undefined);
+                }
+                return result;
+            },
+            unsubscribeKey: (descriptor) => {
+                const { key, ns } = descriptor;
+                decrementInMap(handlerWrapper.keys, key);
+                getFallbackArray(ns).forEach((val) => decrementInMap(handlerWrapper.namespaces, val));
+                if (ns === undefined) {
+                    // subscribing to all namespaces
+                    decrementInMap(handlerWrapper.namespaces, undefined);
+                }
+                return result;
+            },
+        };
+        return result;
+    };
+    const namespacesWithFallbacks = (namespaces) => {
+        if (namespaces.has(undefined)) {
+            const result = new Set(namespaces.keys());
+            result.delete(undefined);
+            getFallbackNamespaces().forEach((ns) => result.add(ns));
+            return result;
+        }
+        return namespaces;
+    };
+    const callHandlers = (key, ns) => {
+        partialListeners.forEach((handler) => {
+            const handlerNamespaces = namespacesWithFallbacks(handler.namespaces);
+            const nsMatches = ns === undefined ||
+                (ns === null || ns === void 0 ? void 0 : ns.findIndex((ns) => handlerNamespaces.has(ns))) !== -1;
+            const keyMatches = key === undefined || handler.keys.has(key) || handler.keys.size === 0;
+            if (nsMatches && keyMatches) {
+                handler.fn({ value: undefined });
+            }
+        });
+    };
+    let queue = [];
+    // merge events in queue into one event
+    const solveQueue = () => {
+        if (queue.length === 0) {
+            return;
+        }
+        listeners.forEach((handler) => {
+            handler({ value: undefined });
+        });
+        const namespaces = new Set();
+        let keys = new Set();
+        queue.forEach((descriptor) => {
+            if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.ns) === undefined) {
+                // when no ns specified, it affets all fallback namespaces
+                namespaces.add(undefined);
+            }
+            else {
+                descriptor.ns.forEach((ns) => namespaces.add(ns));
+            }
+            if ((descriptor === null || descriptor === void 0 ? void 0 : descriptor.key) === undefined) {
+                // when no key specified, it affects all keys
+                keys = undefined;
+            }
+            else if (keys !== undefined) {
+                keys.add(descriptor.key);
+            }
+        });
+        const namespacesArray = Array.from(namespacesWithFallbacks(namespaces).keys());
+        (keys || [undefined]).forEach((key) => {
+            callHandlers(key, namespacesArray);
+        });
+        queue = [];
+    };
+    const emit = (descriptor, delayed) => {
+        queue.push(descriptor);
+        if (!delayed) {
+            solveQueue();
+        }
+        else {
+            Promise.resolve().then(() => {
+                solveQueue();
+            });
+        }
+    };
+    return Object.freeze({ listenSome, listen, emit });
+};
+
+const Events = (getFallbackNamespaces) => {
+    const onPendingLanguageChange = EventEmitter();
+    const onLanguageChange = EventEmitter();
+    const onKeyChange = EventEmitter();
+    const onLoadingChange = EventEmitter();
+    const onFetchingChange = EventEmitter();
+    const onInitialLoaded = EventEmitter();
+    const onKeyUpdate = EventEmitterSelective(getFallbackNamespaces);
+    const onCacheChange = EventEmitter();
+    const onRunningChange = EventEmitter();
+    onInitialLoaded.listen(() => onKeyUpdate.emit());
+    onLanguageChange.listen(() => onKeyUpdate.emit());
+    onCacheChange.listen(({ value }) => {
+        onKeyUpdate.emit({ ns: [value.namespace], key: value.key }, true);
+    });
+    const on = (event, handler) => {
+        switch (event) {
+            case 'pendingLanguage':
+                return onPendingLanguageChange.listen(handler);
+            case 'language':
+                return onLanguageChange.listen(handler);
+            case 'loading':
+                return onLoadingChange.listen(handler);
+            case 'fetching':
+                return onFetchingChange.listen(handler);
+            case 'initialLoad':
+                return onInitialLoaded.listen(handler);
+            case 'running':
+                return onRunningChange.listen(handler);
+            case 'cache':
+                return onCacheChange.listen(handler);
+            case 'keyUpdate':
+                return onKeyUpdate.listen(handler);
+        }
+    };
+    return Object.freeze({
+        onPendingLanguageChange,
+        onLanguageChange,
+        onKeyChange,
+        onKeyUpdate,
+        onLoadingChange,
+        onFetchingChange,
+        onInitialLoaded,
+        onRunningChange,
+        onCacheChange,
+        on,
+    });
+};
+
+const flattenTranslations = (data) => {
+    const result = new Map();
+    Object.entries(data).forEach(([key, value]) => {
+        // ignore empty values
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (typeof value === 'object') {
+            flattenTranslations(value).forEach((flatValue, flatKey) => {
+                result.set(key + '.' + flatKey, flatValue);
+            });
+            return;
+        }
+        result.set(key, value);
+    });
+    return result;
+};
+const decodeCacheKey = (key) => {
+    const [firstPart, secondPart] = key.split(':');
+    return { language: firstPart, namespace: secondPart || '' };
+};
+const encodeCacheKey = ({ language, namespace, }) => {
+    if (namespace) {
+        return `${language}:${namespace}`;
+    }
+    else {
+        return language;
+    }
+};
+
+const Cache = (onCacheChange, backendGetRecord, backendGetDevRecord, withDefaultNs, isInitialLoading, fetchingObserver, loadingObserver) => {
+    const asyncRequests = new Map();
+    const cache = new Map();
+    let staticData = {};
+    let version = 0;
+    function addStaticData(data) {
+        if (data) {
+            staticData = Object.assign(Object.assign({}, staticData), data);
+            Object.entries(data).forEach(([key, value]) => {
+                if (typeof value !== 'function') {
+                    const descriptor = decodeCacheKey(key);
+                    const existing = cache.get(key);
+                    if (!existing || existing.version === 0) {
+                        addRecordInternal(descriptor, value, 0);
+                    }
+                }
+            });
+        }
+    }
+    function invalidate() {
+        asyncRequests.clear();
+        version += 1;
+    }
+    function addRecordInternal(descriptor, data, recordVersion) {
+        const cacheKey = encodeCacheKey(descriptor);
+        cache.set(cacheKey, {
+            data: flattenTranslations(data),
+            version: recordVersion,
+        });
+        onCacheChange.emit(descriptor);
+    }
+    function addRecord(descriptor, data) {
+        addRecordInternal(descriptor, data, version);
+    }
+    function exists(descriptor, strict = false) {
+        const record = cache.get(encodeCacheKey(descriptor));
+        if (record && strict) {
+            return record.version === version;
+        }
+        return Boolean(record);
+    }
+    function getRecord(descriptor) {
+        var _a;
+        return (_a = cache.get(encodeCacheKey(withDefaultNs(descriptor)))) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    function getTranslation(descriptor, key) {
+        var _a;
+        return (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+    }
+    function getTranslationNs(namespaces, languages, key) {
+        var _a;
+        for (const namespace of namespaces) {
+            for (const language of languages) {
+                const value = (_a = cache
+                    .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+                if (value !== undefined && value !== null) {
+                    return namespace;
+                }
+            }
+        }
+        return Array.from(new Set(namespaces));
+    }
+    function getTranslationFallback(namespaces, languages, key) {
+        var _a;
+        for (const namespace of namespaces) {
+            for (const language of languages) {
+                const value = (_a = cache
+                    .get(encodeCacheKey({ language, namespace }))) === null || _a === void 0 ? void 0 : _a.data.get(key);
+                if (value !== undefined && value !== null) {
+                    return value;
+                }
+            }
+        }
+        return undefined;
+    }
+    function changeTranslation(descriptor, key, value) {
+        var _a;
+        const record = (_a = cache.get(encodeCacheKey(descriptor))) === null || _a === void 0 ? void 0 : _a.data;
+        record === null || record === void 0 ? void 0 : record.set(key, value);
+        onCacheChange.emit(Object.assign(Object.assign({}, descriptor), { key }));
+    }
+    function isFetching(ns) {
+        if (isInitialLoading()) {
+            return true;
+        }
+        if (ns === undefined) {
+            return asyncRequests.size > 0;
+        }
+        const namespaces = getFallbackArray(ns);
+        return Boolean(Array.from(asyncRequests.keys()).find((key) => namespaces.includes(decodeCacheKey(key).namespace)));
+    }
+    function isLoading(language, ns) {
+        const namespaces = getFallbackArray(ns);
+        return Boolean(isInitialLoading() ||
+            Array.from(asyncRequests.keys()).find((key) => {
+                const descriptor = decodeCacheKey(key);
+                return ((!namespaces.length || namespaces.includes(descriptor.namespace)) &&
+                    !exists({
+                        namespace: descriptor.namespace,
+                        language: language,
+                    }));
+            }));
+    }
+    function fetchNormal(keyObject) {
+        let dataPromise = undefined;
+        if (!dataPromise) {
+            const staticDataValue = staticData[encodeCacheKey(keyObject)];
+            if (typeof staticDataValue === 'function') {
+                dataPromise = staticDataValue();
+            }
+        }
+        if (!dataPromise) {
+            dataPromise = backendGetRecord(keyObject);
+        }
+        if (!dataPromise) {
+            // return current data or empty object
+            dataPromise = Promise.resolve(cache.get(encodeCacheKey(keyObject)) || {});
+        }
+        return dataPromise;
+    }
+    function fetchData(keyObject, isDev) {
+        var _a;
+        let dataPromise = undefined;
+        if (isDev) {
+            dataPromise = (_a = backendGetDevRecord(keyObject)) === null || _a === void 0 ? void 0 : _a.catch(() => {
+                // eslint-disable-next-line no-console
+                console.warn(`Tolgee: Failed to fetch data from dev backend`);
+                // fallback to normal fetch if dev fails
+                return fetchNormal(keyObject);
+            });
+        }
+        if (!dataPromise) {
+            dataPromise = fetchNormal(keyObject);
+        }
+        return dataPromise;
+    }
+    async function loadRecords(descriptors, isDev) {
+        const withPromises = descriptors.map((descriptor) => {
+            const keyObject = withDefaultNs(descriptor);
+            const cacheKey = encodeCacheKey(keyObject);
+            const existingPromise = asyncRequests.get(cacheKey);
+            if (existingPromise) {
+                return {
+                    new: false,
+                    promise: existingPromise,
+                    keyObject,
+                    cacheKey,
+                };
+            }
+            const dataPromise = fetchData(keyObject, isDev);
+            asyncRequests.set(cacheKey, dataPromise);
+            return {
+                new: true,
+                promise: dataPromise,
+                keyObject,
+                cacheKey,
+            };
+        });
+        fetchingObserver.notify();
+        loadingObserver.notify();
+        const results = await Promise.all(withPromises.map((val) => val.promise));
+        withPromises.forEach((value, i) => {
+            const promiseChanged = asyncRequests.get(value.cacheKey) !== value.promise;
+            // if promise has changed in between, it means cache been invalidated or
+            // new data are being fetched
+            if (value.new && !promiseChanged) {
+                asyncRequests.delete(value.cacheKey);
+                const data = results[i];
+                if (data) {
+                    addRecord(value.keyObject, data);
+                }
+            }
+        });
+        fetchingObserver.notify();
+        loadingObserver.notify();
+        return withPromises.map((val) => getRecord(val.keyObject));
+    }
+    function getAllRecords() {
+        const entries = Array.from(cache.entries());
+        return entries.map(([key, entry]) => {
+            return Object.assign(Object.assign({}, decodeCacheKey(key)), { data: entry.data });
+        });
+    }
+    return Object.freeze({
+        addStaticData,
+        invalidate,
+        addRecord,
+        exists,
+        getRecord,
+        getTranslation,
+        getTranslationNs,
+        getTranslationFallback,
+        changeTranslation,
+        isFetching,
+        isLoading,
+        loadRecords,
+        getAllRecords,
+    });
+};
+
+function isPromise(value) {
+    return Boolean(value && typeof value.then === 'function');
+}
+const valueOrPromise = (value, callback) => {
+    if (isPromise(value)) {
+        return Promise.resolve(value).then(callback);
+    }
+    else {
+        return callback(value);
+    }
+};
+const missingOptionError = (option) => `Tolgee: You need to specify '${option}' option`;
+
+const PluginService = (getLanguage, getInitialOptions, getObserverOptions, getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation) => {
+    const plugins = {
+        ui: undefined,
+        observer: undefined,
+    };
+    const instances = {
+        formatters: [],
+        finalFormatter: undefined,
+        observer: undefined,
+        devBackend: undefined,
+        backends: [],
+        ui: undefined,
+        languageDetector: undefined,
+        languageStorage: undefined,
+    };
+    const onClick = async (event, { keysAndDefaults }) => {
+        var _a;
+        const withNs = keysAndDefaults.map(({ key, ns, defaultValue }) => ({
+            key,
+            defaultValue,
+            ns: getFallbackArray(getTranslationNs({ key, ns, defaultValue })),
+            translation: getTranslation({
+                key,
+                ns,
+            }),
+        }));
+        (_a = instances.ui) === null || _a === void 0 ? void 0 : _a.handleElementClick(event, withNs);
+    };
+    const run = (isDev) => {
+        var _a, _b;
+        if (!instances.ui && plugins.ui) {
+            instances.ui = new plugins.ui({
+                apiKey: getInitialOptions().apiKey,
+                apiUrl: getInitialOptions().apiUrl,
+                highlight,
+                changeTranslation,
+            });
+        }
+        if (!instances.observer) {
+            instances.observer = (_a = plugins.observer) === null || _a === void 0 ? void 0 : _a.call(plugins, {
+                translate,
+                onClick,
+                options: getObserverOptions(),
+            });
+        }
+        (_b = instances.observer) === null || _b === void 0 ? void 0 : _b.run({ mouseHighlight: isDev });
+    };
+    const stop = () => {
+        var _a;
+        instances.ui = undefined;
+        (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.stop();
+    };
+    const highlight = (key, ns) => {
+        var _a, _b;
+        return ((_b = (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.highlight) === null || _b === void 0 ? void 0 : _b.call(_a, key, ns)) || { unhighlight() { } };
+    };
+    const translate = (props) => {
+        const translation = getTranslation(props);
+        return formatTranslation(Object.assign(Object.assign({}, props), { translation, formatEnabled: true }));
+    };
+    const setObserver = (observer) => {
+        plugins.observer = observer;
+    };
+    const hasObserver = () => {
+        return Boolean(plugins.observer);
+    };
+    const addFormatter = (formatter) => {
+        if (formatter) {
+            instances.formatters.push(formatter);
+        }
+    };
+    const setFinalFormatter = (formatter) => {
+        instances.finalFormatter = formatter;
+    };
+    const setUi = (ui) => {
+        plugins.ui = (ui === null || ui === void 0 ? void 0 : ui.UI) || ui;
+    };
+    const hasUi = () => {
+        return Boolean(plugins.ui);
+    };
+    const setLanguageStorage = (storage) => {
+        instances.languageStorage = storage;
+    };
+    const getLanguageStorage = () => {
+        return instances.languageStorage;
+    };
+    const setStoredLanguage = (language) => {
+        var _a;
+        (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.setLanguage(language);
+    };
+    const setLanguageDetector = (detector) => {
+        instances.languageDetector = detector;
+    };
+    const getLanguageDetector = () => {
+        return instances.languageDetector;
+    };
+    const detectLanguage = () => {
+        if (!instances.languageDetector) {
+            return undefined;
+        }
+        const availableLanguages = getAvailableLanguages();
+        return instances.languageDetector.getLanguage({
+            availableLanguages,
+        });
+    };
+    const getInitialLanguage = () => {
+        var _a;
+        const availableLanguages = getAvailableLanguages();
+        const languageOrPromise = (_a = instances.languageStorage) === null || _a === void 0 ? void 0 : _a.getLanguage();
+        return valueOrPromise(languageOrPromise, (language) => {
+            if ((!availableLanguages || availableLanguages.includes(language)) &&
+                language) {
+                return language;
+            }
+            return detectLanguage();
+        });
+    };
+    const addBackend = (backend) => {
+        if (backend) {
+            instances.backends.push(backend);
+        }
+    };
+    const setDevBackend = (backend) => {
+        instances.devBackend = backend;
+    };
+    const getDevBackend = () => {
+        return instances.devBackend;
+    };
+    const getBackendDevRecord = ({ language, namespace }) => {
+        var _a;
+        return (_a = instances.devBackend) === null || _a === void 0 ? void 0 : _a.getRecord({
+            apiKey: getInitialOptions().apiKey,
+            apiUrl: getInitialOptions().apiUrl,
+            language,
+            namespace,
+        });
+    };
+    const getBackendRecord = ({ language, namespace }) => {
+        for (const backend of instances.backends) {
+            const data = backend.getRecord({ language, namespace });
+            if (isPromise(data)) {
+                return data === null || data === void 0 ? void 0 : data.catch((e) => {
+                    // eslint-disable-next-line no-console
+                    console.error(e);
+                    return {};
+                });
+            }
+            if (data !== undefined) {
+                return data;
+            }
+        }
+        return undefined;
+    };
+    const formatTranslation = ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }) => {
+        var _a;
+        const formattableTranslation = translation || defaultValue;
+        let result = formattableTranslation || (orEmpty ? '' : key);
+        if (instances.observer && !noWrap) {
+            result = instances.observer.wrap({
+                key,
+                translation: result,
+                defaultValue,
+                params,
+                ns,
+            });
+        }
+        const language = getLanguage();
+        const isFormatEnabled = formatEnabled || !((_a = instances.observer) === null || _a === void 0 ? void 0 : _a.outputNotFormattable);
+        if (formattableTranslation && language && isFormatEnabled) {
+            for (const formatter of instances.formatters) {
+                result = formatter.format({
+                    translation: result,
+                    language,
+                    params,
+                });
+            }
+        }
+        if (instances.finalFormatter &&
+            formattableTranslation &&
+            language &&
+            isFormatEnabled) {
+            result = instances.finalFormatter.format({
+                translation: result,
+                language,
+                params,
+            });
+        }
+        return result;
+    };
+    const wrap = (params) => {
+        var _a;
+        if (instances.observer) {
+            return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.wrap(params);
+        }
+        return params.translation;
+    };
+    const unwrap = (text) => {
+        var _a;
+        if (instances.observer) {
+            return (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.unwrap(text);
+        }
+        return { text, keys: [] };
+    };
+    const retranslate = () => {
+        var _a;
+        (_a = instances.observer) === null || _a === void 0 ? void 0 : _a.retranslate();
+    };
+    return Object.freeze({
+        setFinalFormatter,
+        addFormatter,
+        formatTranslation,
+        setObserver,
+        hasObserver,
+        setUi,
+        hasUi,
+        addBackend,
+        setDevBackend,
+        getDevBackend,
+        getBackendRecord,
+        getBackendDevRecord,
+        setLanguageDetector,
+        getLanguageDetector,
+        setLanguageStorage,
+        getLanguageStorage,
+        getInitialLanguage,
+        setStoredLanguage,
+        run,
+        stop,
+        retranslate,
+        highlight,
+        wrap,
+        unwrap,
+    });
+};
+
+const ValueObserver = (initialValue, valueGetter, handler) => {
+    let previousValue = initialValue;
+    function init(value) {
+        previousValue = value;
+    }
+    function notify() {
+        const value = valueGetter();
+        if (previousValue !== value) {
+            handler(value);
+        }
+        previousValue = value;
+    }
+    return Object.freeze({
+        init,
+        notify,
+    });
+};
+
+const defaultValues$1 = {
+    tagAttributes: {
+        textarea: ['placeholder'],
+        input: ['value', 'placeholder'],
+        img: ['alt'],
+        '*': ['aria-label', 'title'],
+    },
+    restrictedElements: ['script', 'style'],
+    highlightKeys: ['Alt'],
+    highlightColor: 'rgb(255, 0, 0)',
+    highlightWidth: 5,
+    inputPrefix: '%-%tolgee:',
+    inputSuffix: '%-%',
+    passToParent: ['option', 'optgroup'],
+};
+const initObserverOptions = (options) => {
+    return Object.assign(Object.assign({}, defaultValues$1), options);
+};
+
+const defaultValues = {
+    defaultNs: '',
+};
+const initState = (options, previousState) => {
+    const initialOptions = Object.assign(Object.assign(Object.assign({}, defaultValues), previousState === null || previousState === void 0 ? void 0 : previousState.initialOptions), options);
+    // remove extra '/' from url end
+    const apiUrl = initialOptions.apiUrl;
+    initialOptions.apiUrl = apiUrl ? apiUrl.replace(/\/+$/, '') : apiUrl;
+    return {
+        initialOptions,
+        activeNamespaces: (previousState === null || previousState === void 0 ? void 0 : previousState.activeNamespaces) || new Map(),
+        language: previousState === null || previousState === void 0 ? void 0 : previousState.language,
+        pendingLanguage: previousState === null || previousState === void 0 ? void 0 : previousState.language,
+        isInitialLoading: false,
+        isRunning: false,
+    };
+};
+
+const State = (onLanguageChange, onPendingLanguageChange, onRunningChange) => {
+    let state = initState();
+    let observerOptions = initObserverOptions();
+    let devCredentials = undefined;
+    function init(options) {
+        state = initState(options, state);
+    }
+    function isRunning() {
+        return state.isRunning;
+    }
+    function setRunning(value) {
+        if (state.isRunning !== value) {
+            state.isRunning = value;
+            onRunningChange.emit(value);
+        }
+    }
+    function isInitialLoading() {
+        return state.isInitialLoading;
+    }
+    function setInitialLoading(value) {
+        state.isInitialLoading = value;
+    }
+    function getLanguage() {
+        return state.language || state.initialOptions.language;
+    }
+    function setLanguage(language) {
+        if (state.language !== language) {
+            state.language = language;
+            onLanguageChange.emit(language);
+        }
+    }
+    function getPendingLanguage() {
+        return state.pendingLanguage || getLanguage();
+    }
+    function setPendingLanguage(language) {
+        if (state.pendingLanguage !== language) {
+            state.pendingLanguage = language;
+            onPendingLanguageChange.emit(language);
+        }
+    }
+    function getInitialOptions() {
+        return Object.assign(Object.assign({}, state.initialOptions), devCredentials);
+    }
+    function addActiveNs(ns) {
+        const namespaces = getFallbackArray(ns);
+        namespaces.forEach((namespace) => {
+            const value = state.activeNamespaces.get(namespace);
+            if (value !== undefined) {
+                state.activeNamespaces.set(namespace, value + 1);
+            }
+            else {
+                state.activeNamespaces.set(namespace, 1);
+            }
+        });
+    }
+    function removeActiveNs(ns) {
+        const namespaces = getFallbackArray(ns);
+        namespaces.forEach((namespace) => {
+            const value = state.activeNamespaces.get(namespace);
+            if (value !== undefined && value > 1) {
+                state.activeNamespaces.set(namespace, value - 1);
+            }
+            else {
+                state.activeNamespaces.delete(namespace);
+            }
+        });
+    }
+    function getRequiredNamespaces() {
+        return unique([
+            ...(state.initialOptions.ns || [state.initialOptions.defaultNs]),
+            ...state.activeNamespaces.keys(),
+        ]);
+    }
+    function getFallbackLangs(lang) {
+        const language = lang || getLanguage();
+        if (!language) {
+            return [];
+        }
+        return unique([
+            language,
+            ...getFallbackFromStruct(language, state.initialOptions.fallbackLanguage),
+        ]);
+    }
+    function getFallbackNamespaces() {
+        const defaultNs = state.initialOptions.defaultNs;
+        const fallbackNs = state.initialOptions.fallbackNs;
+        const fallbackNamespaces = typeof defaultNs === 'string' ? [defaultNs] : [];
+        return unique([...fallbackNamespaces, ...getFallbackArray(fallbackNs)]);
+    }
+    function getAvailableLanguages() {
+        if (state.initialOptions.availableLanguages) {
+            return state.initialOptions.availableLanguages;
+        }
+        else if (state.initialOptions.staticData) {
+            const languagesFromStaticData = Object.keys(state.initialOptions.staticData).map((key) => decodeCacheKey(key).language);
+            return Array.from(new Set(languagesFromStaticData));
+        }
+    }
+    function withDefaultNs(descriptor) {
+        return {
+            namespace: descriptor.namespace === undefined
+                ? getInitialOptions().defaultNs
+                : descriptor.namespace,
+            language: descriptor.language,
+        };
+    }
+    function overrideCredentials(credentials) {
+        devCredentials = credentials;
+    }
+    function setObserverOptions(options) {
+        observerOptions = initObserverOptions(options);
+    }
+    function getObserverOptions() {
+        return observerOptions;
+    }
+    return Object.freeze({
+        init,
+        isRunning,
+        setRunning,
+        isInitialLoading,
+        setInitialLoading,
+        getLanguage,
+        setLanguage,
+        getPendingLanguage,
+        setPendingLanguage,
+        getInitialOptions,
+        addActiveNs,
+        removeActiveNs,
+        getRequiredNamespaces,
+        getFallbackLangs,
+        getFallbackNamespaces,
+        getAvailableLanguages,
+        withDefaultNs,
+        overrideCredentials,
+        setObserverOptions,
+        getObserverOptions,
+    });
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function parseCombinedOptions(_a) {
+    var { ns, noWrap, orEmpty, params } = _a, rest = __rest(_a, ["ns", "noWrap", "orEmpty", "params"]);
+    const options = {
+        ns: ns,
+        noWrap: noWrap,
+        orEmpty: orEmpty,
+        params: Object.assign(Object.assign({}, rest), params),
+    };
+    return options;
+}
+const getTranslateParams = (keyOrProps, ...params) => {
+    let result = {};
+    let options;
+    if (typeof keyOrProps === 'object') {
+        result = keyOrProps;
+    }
+    else {
+        result.key = keyOrProps;
+        if (typeof params[0] === 'string') {
+            result.defaultValue = params[0];
+            options = params[1];
+        }
+        else if (typeof params[0] === 'object') {
+            options = params[0];
+        }
+    }
+    if (options) {
+        result = Object.assign(Object.assign({}, parseCombinedOptions(options)), result);
+    }
+    return result;
+};
+
+const Controller = ({ options }) => {
+    const events = Events(getFallbackNamespaces);
+    const fetchingObserver = ValueObserver(false, () => cache.isFetching(), events.onFetchingChange.emit);
+    const loadingObserver = ValueObserver(false, () => isLoading(), events.onLoadingChange.emit);
+    const state = State(events.onLanguageChange, events.onPendingLanguageChange, events.onRunningChange);
+    const pluginService = PluginService(state.getLanguage, state.getInitialOptions, state.getObserverOptions, state.getAvailableLanguages, getTranslationNs, getTranslation, changeTranslation);
+    const cache = Cache(events.onCacheChange, pluginService.getBackendRecord, pluginService.getBackendDevRecord, state.withDefaultNs, state.isInitialLoading, fetchingObserver, loadingObserver);
+    if (options) {
+        init(options);
+    }
+    events.onKeyUpdate.listen(() => {
+        if (state.isRunning()) {
+            pluginService.retranslate();
+        }
+    });
+    function changeTranslation(descriptor, key, value) {
+        const keyObject = state.withDefaultNs(descriptor);
+        const previousValue = cache.getTranslation(keyObject, key);
+        cache.changeTranslation(keyObject, key, value);
+        return {
+            revert: () => {
+                cache.changeTranslation(keyObject, key, previousValue);
+            },
+        };
+    }
+    function getFallbackNamespaces() {
+        return state.getFallbackNamespaces();
+    }
+    function init(options) {
+        state.init(options);
+        cache.addStaticData(state.getInitialOptions().staticData);
+    }
+    function isLoading(ns) {
+        return cache.isLoading(state.getLanguage(), ns);
+    }
+    function isDev() {
+        return Boolean(state.getInitialOptions().apiKey &&
+            state.getInitialOptions().apiUrl &&
+            pluginService.getDevBackend());
+    }
+    async function addActiveNs(ns, forget) {
+        if (!forget) {
+            state.addActiveNs(ns);
+        }
+        if (state.isRunning()) {
+            await loadRequiredRecords(undefined, ns);
+        }
+    }
+    function getRequiredRecords(lang, ns) {
+        const languages = state.getFallbackLangs(lang);
+        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+        const result = [];
+        languages.forEach((language) => {
+            namespaces.forEach((namespace) => {
+                if (!cache.exists({ language, namespace }, true)) {
+                    result.push({ language, namespace });
+                }
+            });
+        });
+        return result;
+    }
+    function isLoaded(ns) {
+        const language = state.getLanguage();
+        if (!language) {
+            return false;
+        }
+        const languages = state.getFallbackLangs(language);
+        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getRequiredNamespaces();
+        const result = [];
+        languages.forEach((language) => {
+            namespaces.forEach((namespace) => {
+                if (!cache.exists({ language, namespace })) {
+                    result.push({ language, namespace });
+                }
+            });
+        });
+        return result.length === 0;
+    }
+    function loadRequiredRecords(lang, ns) {
+        const descriptors = getRequiredRecords(lang, ns);
+        if (descriptors.length) {
+            return valueOrPromise(loadRecords(descriptors), () => { });
+        }
+    }
+    async function changeLanguage(language) {
+        if (state.getPendingLanguage() === language &&
+            state.getLanguage() === language) {
+            return;
+        }
+        state.setPendingLanguage(language);
+        if (state.isRunning()) {
+            await loadRequiredRecords(language);
+        }
+        if (language === state.getPendingLanguage()) {
+            // there might be parallel language change
+            // we only want to apply latest
+            state.setLanguage(language);
+            pluginService.setStoredLanguage(language);
+        }
+    }
+    function getTranslationNs({ key, ns, }) {
+        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getFallbackNamespaces();
+        const languages = state.getFallbackLangs();
+        return cache.getTranslationNs(namespaces, languages, key);
+    }
+    function getTranslation({ key, ns, }) {
+        const namespaces = ns !== undefined ? getFallbackArray(ns) : state.getFallbackNamespaces();
+        const languages = state.getFallbackLangs();
+        return cache.getTranslationFallback(namespaces, languages, key);
+    }
+    function loadInitial() {
+        const data = valueOrPromise(initializeLanguage(), () => {
+            // fail if there is no language
+            return loadRequiredRecords();
+        });
+        if (isPromise(data)) {
+            state.setInitialLoading(true);
+            fetchingObserver.notify();
+            loadingObserver.notify();
+            return Promise.resolve(data).then(() => {
+                state.setInitialLoading(false);
+                fetchingObserver.notify();
+                loadingObserver.notify();
+                events.onInitialLoaded.emit();
+            });
+        }
+        else {
+            events.onInitialLoaded.emit();
+        }
+    }
+    function initializeLanguage() {
+        const existingLanguage = state.getLanguage();
+        if (existingLanguage) {
+            return;
+        }
+        if (!state.getInitialOptions().defaultLanguage) {
+            throw new Error(missingOptionError('defaultLanguage'));
+        }
+        const languageOrPromise = pluginService.getInitialLanguage();
+        return valueOrPromise(languageOrPromise, (lang) => {
+            const language = lang ||
+                state.getInitialOptions().defaultLanguage;
+            language && state.setLanguage(language);
+        });
+    }
+    async function loadRecord(descriptor) {
+        return (await loadRecords([descriptor]))[0];
+    }
+    function loadRecords(descriptors) {
+        return cache.loadRecords(descriptors, isDev());
+    }
+    const checkCorrectConfiguration = () => {
+        const languageDetector = pluginService.getLanguageDetector();
+        if (languageDetector) {
+            const availableLanguages = state.getAvailableLanguages();
+            if (!availableLanguages) {
+                throw new Error(missingOptionError('availableLanguages'));
+            }
+        }
+        if (!state.getLanguage() && !state.getInitialOptions().defaultLanguage) {
+            if (languageDetector) {
+                throw new Error(missingOptionError('defaultLanguage'));
+            }
+            else {
+                throw new Error(missingOptionError('language'));
+            }
+        }
+    };
+    function run() {
+        let result = undefined;
+        checkCorrectConfiguration();
+        if (!state.isRunning()) {
+            if (isDev()) {
+                cache.invalidate();
+            }
+            state.setRunning(true);
+            pluginService.run(isDev());
+            result = loadInitial();
+        }
+        return Promise.resolve(result);
+    }
+    function stop() {
+        if (state.isRunning()) {
+            pluginService.stop();
+            state.setRunning(false);
+        }
+    }
+    const t = (...args) => {
+        // @ts-ignore
+        const params = getTranslateParams(...args);
+        const translation = getTranslation(params);
+        return pluginService.formatTranslation(Object.assign(Object.assign({}, params), { translation }));
+    };
+    return Object.freeze(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, events), state), pluginService), cache), { init,
+        changeLanguage,
+        getTranslation,
+        changeTranslation,
+        addActiveNs,
+        loadRequiredRecords,
+        loadRecords,
+        loadRecord,
+        isLoading,
+        isLoaded,
+        t,
+        isDev,
+        run,
+        stop }));
+};
+
+const Tolgee = (options) => {
+    const controller = Controller({
+        options,
+    });
+    const pluginTools = Object.freeze({
+        setFinalFormatter: controller.setFinalFormatter,
+        addFormatter: controller.addFormatter,
+        setObserver: controller.setObserver,
+        hasObserver: controller.hasObserver,
+        setUi: controller.setUi,
+        hasUi: controller.hasUi,
+        setDevBackend: controller.setDevBackend,
+        addBackend: controller.addBackend,
+        setLanguageDetector: controller.setLanguageDetector,
+        setLanguageStorage: controller.setLanguageStorage,
+        overrideCredentials: controller.overrideCredentials,
+    });
+    const withRestart = (callback) => {
+        const wasRunning = controller.isRunning();
+        wasRunning && controller.stop();
+        callback();
+        wasRunning && controller.run();
+    };
+    const tolgee = Object.freeze({
+        // event listeners
+        on: controller.on,
+        onKeyUpdate: controller.onKeyUpdate.listenSome,
+        // state
+        getLanguage: controller.getLanguage,
+        getPendingLanguage: controller.getPendingLanguage,
+        changeLanguage: controller.changeLanguage,
+        changeTranslation: controller.changeTranslation,
+        addActiveNs: controller.addActiveNs,
+        removeActiveNs: controller.removeActiveNs,
+        loadRecords: controller.loadRecords,
+        loadRecord: controller.loadRecord,
+        addStaticData: controller.addStaticData,
+        getRecord: controller.getRecord,
+        getAllRecords: controller.getAllRecords,
+        isLoaded: controller.isLoaded,
+        isInitialLoading: controller.isInitialLoading,
+        isLoading: controller.isLoading,
+        isFetching: controller.isFetching,
+        isRunning: controller.isRunning,
+        run: controller.run,
+        stop: controller.stop,
+        t: controller.t,
+        highlight: controller.highlight,
+        getInitialOptions: controller.getInitialOptions,
+        isDev: controller.isDev,
+        wrap: controller.wrap,
+        unwrap: controller.unwrap,
+        // plugins
+        setObserverOptions: (options) => {
+            controller.setObserverOptions(options);
+            return tolgee;
+        },
+        use: (plugin) => {
+            if (plugin) {
+                withRestart(() => plugin(tolgee, pluginTools));
+            }
+            return tolgee;
+        },
+        init: (options) => {
+            withRestart(() => controller.init(options));
+            return tolgee;
+        },
+    });
+    return tolgee;
+};
+
+const RESTRICTED_ASCENDANT_ATTRIBUTE = 'data-tolgee-restricted';
+const TOLGEE_ATTRIBUTE_NAME = '_tolgee';
+const TOLGEE_HIGHLIGHTER_CLASS = '_tolgee-highlighter';
+const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = 'data-tolgee-key-only';
+
+const ERROR_PARAM_EMPTY = 0, ERROR_UNEXPECTED_CHAR = 1, ERROR_UNEXPECTED_END = 2;
+class FormatError extends Error {
+    constructor(code, index, text) {
+        let error;
+        if (code === ERROR_PARAM_EMPTY) {
+            error = 'Empty parameter';
+        }
+        else if (code === ERROR_UNEXPECTED_CHAR) {
+            error = 'Unexpected character';
+        }
+        else {
+            error = 'Unexpected end';
+        }
+        super(`Tolgee parser: ${error} at ${index} in "${text}"`);
+        this.code = code;
+        this.index = index;
+    }
+}
+
+function isWhitespace(ch) {
+    return /\s/.test(ch);
+}
+const STATE_TEXT = 0, STATE_ESCAPE_MAYBE = 1, STATE_ESCAPE = 2, STATE_PARAM = 3, STATE_PARAM_AFTER = 4;
+const END_STATES = new Set([
+    STATE_ESCAPE,
+    STATE_ESCAPE_MAYBE,
+    STATE_TEXT,
+]);
+const CHAR_ESCAPE = "'";
+const ESCAPABLE = new Set(['{', '}', CHAR_ESCAPE]);
+const isAllowedInParam = (char) => {
+    return /[0-9a-zA-Z_]/.test(char);
+};
+function formatParser(translation) {
+    let state = STATE_TEXT;
+    let text = '';
+    let param = '';
+    let ch = '';
+    const texts = [];
+    const params = [];
+    let i = 0;
+    function parsingError(code) {
+        throw new FormatError(code, i, translation);
+    }
+    const addText = () => {
+        texts.push(text);
+        text = '';
+    };
+    const addParamChar = () => {
+        if (!isAllowedInParam(ch)) {
+            parsingError(ERROR_UNEXPECTED_CHAR);
+        }
+        param += ch;
+    };
+    const addParam = () => {
+        if (param === '') {
+            parsingError(ERROR_PARAM_EMPTY);
+        }
+        params.push(param);
+        param = '';
+    };
+    for (i = 0; i < translation.length; i++) {
+        ch = translation[i];
+        switch (state) {
+            case STATE_TEXT:
+                if (ch === CHAR_ESCAPE) {
+                    text += ch;
+                    state = STATE_ESCAPE_MAYBE;
+                }
+                else if (ch === '{') {
+                    addText();
+                    state = STATE_PARAM;
+                }
+                else {
+                    text += ch;
+                    state = STATE_TEXT;
+                }
+                break;
+            case STATE_ESCAPE_MAYBE:
+                if (ESCAPABLE.has(ch)) {
+                    text = text.slice(0, -1) + ch;
+                    state = STATE_ESCAPE;
+                }
+                else {
+                    text += ch;
+                    state = STATE_TEXT;
+                }
+                break;
+            case STATE_ESCAPE:
+                if (ch === CHAR_ESCAPE) {
+                    state = STATE_TEXT;
+                }
+                else {
+                    text += ch;
+                    state = STATE_ESCAPE;
+                }
+                break;
+            case STATE_PARAM:
+                if (ch === '}') {
+                    addParam();
+                    state = STATE_TEXT;
+                }
+                else if (!isWhitespace(ch)) {
+                    addParamChar();
+                    state = STATE_PARAM;
+                }
+                else if (param !== '') {
+                    addParam();
+                    state = STATE_PARAM_AFTER;
+                }
+                break;
+            case STATE_PARAM_AFTER:
+                if (ch == '}') {
+                    state = STATE_TEXT;
+                }
+                else if (isWhitespace(ch)) {
+                    state = STATE_PARAM_AFTER;
+                }
+                else {
+                    parsingError(ERROR_UNEXPECTED_CHAR);
+                }
+        }
+    }
+    if (!END_STATES.has(state)) {
+        parsingError(ERROR_UNEXPECTED_END);
+    }
+    addText();
+    return [texts, params];
+}
+
+function formatter(translation, params) {
+    const [texts, pars] = formatParser(translation);
+    const result = [texts[0]];
+    for (let i = 1; i < texts.length; i++) {
+        const parameter = params === null || params === void 0 ? void 0 : params[pars[i - 1]];
+        if (parameter === undefined) {
+            throw new Error(`Missing parameter "${pars[i - 1]}" in "${translation}"`);
+        }
+        result.push(String(parameter));
+        result.push(texts[i]);
+    }
+    return result.join('');
+}
+
+function FormatSimpleCreator() {
+    return {
+        format: ({ translation, params }) => formatter(translation, params),
+    };
+}
+const FormatSimple = () => (tolgee, tools) => {
+    tools.setFinalFormatter(FormatSimpleCreator());
+    return tolgee;
+};
+
+export { FormatSimple, RESTRICTED_ASCENDANT_ATTRIBUTE, TOLGEE_ATTRIBUTE_NAME, TOLGEE_HIGHLIGHTER_CLASS, TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE, Tolgee, getFallback, getFallbackArray, getTranslateParams };
+//# sourceMappingURL=tolgee.esm.js.map