@messagevisor/sdk 0.0.1 → 0.2.0

package/lib/instance.js

@@ -0,0 +1,1000 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messagevisor = void 0;
+exports.createMessagevisorCache = createMessagevisorCache;
+exports.createMessagevisor = createMessagevisor;
+const conditions_1 = require("./conditions");
+const DEFAULT_CURRENCY = "USD";
+const LOG_PREFIX = "[Messagevisor]";
+class MessagevisorCloseError extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.name = "MessagevisorCloseError";
+        this.errors = errors;
+    }
+}
+function createEmptyRecord() {
+    return {};
+}
+function createMessagevisorCache() {
+    return {
+        numberFormat: createEmptyRecord(),
+        dateTimeFormat: createEmptyRecord(),
+        relativeTimeFormat: createEmptyRecord(),
+        pluralRules: createEmptyRecord(),
+        listFormat: createEmptyRecord(),
+        displayNames: createEmptyRecord(),
+    };
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(parent, child) {
+    if (typeof parent === "undefined") {
+        return child;
+    }
+    if (typeof child === "undefined") {
+        return parent;
+    }
+    if (!isPlainObject(parent) || !isPlainObject(child)) {
+        return child;
+    }
+    const result = { ...parent };
+    for (const key of Object.keys(child)) {
+        result[key] = deepMerge(result[key], child[key]);
+    }
+    return result;
+}
+function getDefaultTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function resolveCurrency(optionCurrency, presetCurrency, instanceCurrency) {
+    return optionCurrency || presetCurrency || instanceCurrency || DEFAULT_CURRENCY;
+}
+function resolveTimeZone(optionTimeZone, formatTimeZone, instanceTimeZone) {
+    return optionTimeZone || formatTimeZone || instanceTimeZone || getDefaultTimeZone();
+}
+function resolveDateTimeOptions(formatOptions, options, instanceTimeZone) {
+    return {
+        ...(formatOptions || {}),
+        timeZone: resolveTimeZone(options.timeZone, formatOptions === null || formatOptions === void 0 ? void 0 : formatOptions.timeZone, instanceTimeZone),
+    };
+}
+function shouldLog(currentLevel, level) {
+    const order = ["fatal", "error", "warn", "info", "debug"];
+    return order.indexOf(currentLevel) >= order.indexOf(level);
+}
+function mergeStoredDatafile(existing, incoming) {
+    var _a;
+    if (!existing) {
+        return incoming;
+    }
+    return {
+        schemaVersion: incoming.schemaVersion,
+        messagevisorVersion: incoming.messagevisorVersion,
+        revision: incoming.revision,
+        target: incoming.target,
+        locale: incoming.locale,
+        direction: (_a = incoming.direction) !== null && _a !== void 0 ? _a : existing.direction,
+        formats: incoming.formats,
+        segments: {
+            ...(existing.segments || {}),
+            ...(incoming.segments || {}),
+        },
+        messages: {
+            ...(existing.messages || {}),
+            ...(incoming.messages || {}),
+        },
+        translations: {
+            ...(existing.translations || {}),
+            ...(incoming.translations || {}),
+        },
+    };
+}
+class Messagevisor {
+    constructor(options = {}) {
+        this.datafiles = {};
+        this.defaultTranslationsByLocale = {};
+        this.defaultFormatsByLocale = {};
+        this.locale = null;
+        this.context = {};
+        this.logLevel = "info";
+        this.modules = [];
+        this.moduleDiagnosticSubscriptions = [];
+        this.moduleApis = {};
+        this.moduleApiId = 0;
+        this.closed = false;
+        this.version = 0;
+        this.listeners = {
+            change: [],
+            error: [],
+            datafile_set: [],
+            locale_set: [],
+            context_set: [],
+            currency_set: [],
+            timeZone_set: [],
+        };
+        this.currency = options.currency;
+        this.timeZone = options.timeZone;
+        this.context = options.context || {};
+        this.resolveFlag = options.resolveFlag;
+        this.resolveVariation = options.resolveVariation;
+        this.logLevel = options.logLevel || "info";
+        this.onDiagnostic = options.onDiagnostic;
+        this.cache = options.cache || createMessagevisorCache();
+        this.setFlagResolver(options.resolveFlag);
+        this.setVariationResolver(options.resolveVariation);
+        (options.modules || []).forEach((module) => {
+            this.addModule(module);
+        });
+        if (options.defaultTranslations) {
+            this.defaultTranslationsByLocale = { ...options.defaultTranslations };
+        }
+        if (options.defaultFormats) {
+            this.defaultFormatsByLocale = { ...options.defaultFormats };
+        }
+        if (options.datafile) {
+            this.setDatafile(options.datafile);
+        }
+        else {
+            this.locale = options.locale || null;
+        }
+        this.reportDiagnostic({
+            level: "info",
+            code: "sdk_initialized",
+            message: "SDK initialized",
+        });
+    }
+    subscribe(callback) {
+        if (this.closed) {
+            return () => { };
+        }
+        return this.on("change", callback);
+    }
+    on(eventName, callback) {
+        if (this.closed) {
+            return () => { };
+        }
+        if (this.listeners[eventName].indexOf(callback) === -1) {
+            this.listeners[eventName].push(callback);
+        }
+        return () => {
+            this.listeners[eventName] = this.listeners[eventName].filter((listener) => listener !== callback);
+        };
+    }
+    getSnapshot() {
+        var _a;
+        const datafileRevisionsByLocale = {};
+        Object.keys(this.datafiles).forEach((locale) => {
+            datafileRevisionsByLocale[locale] = this.datafiles[locale].revision;
+        });
+        return {
+            version: this.version,
+            locale: this.locale,
+            direction: this.locale ? (_a = this.datafiles[this.locale]) === null || _a === void 0 ? void 0 : _a.direction : undefined,
+            context: { ...this.context },
+            currency: this.currency,
+            timeZone: this.timeZone,
+            datafileLocales: Object.keys(this.datafiles),
+            datafileRevisionsByLocale,
+        };
+    }
+    addModule(module) {
+        if (this.closed) {
+            return;
+        }
+        if (module.name &&
+            this.modules.some((registeredModule) => registeredModule.name === module.name)) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "duplicate_module",
+                message: "Duplicate module name",
+                moduleName: module.name,
+            });
+            return;
+        }
+        this.runModuleSetup(module);
+        this.modules.push(module);
+    }
+    removeModule(name) {
+        if (this.closed) {
+            return;
+        }
+        const removedModules = this.modules.filter((module) => module.name === name);
+        this.modules = this.modules.filter((module) => module.name !== name);
+        removedModules.forEach((module) => this.clearModuleDiagnosticSubscriptions(module));
+    }
+    setFlagResolver(resolver) {
+        this.resolveFlag = resolver;
+    }
+    setVariationResolver(resolver) {
+        this.resolveVariation = resolver;
+    }
+    setCurrency(currency) {
+        const previousSnapshot = this.getSnapshot();
+        const previousCurrency = this.currency;
+        this.currency = currency;
+        this.emit("currency_set", previousSnapshot, {
+            currency,
+            previousCurrency,
+        });
+    }
+    getCurrency() {
+        return this.currency;
+    }
+    setTimeZone(timeZone) {
+        const previousSnapshot = this.getSnapshot();
+        const previousTimeZone = this.timeZone;
+        this.timeZone = timeZone;
+        this.emit("timeZone_set", previousSnapshot, {
+            timeZone,
+            previousTimeZone,
+        });
+    }
+    getTimeZone() {
+        return this.timeZone;
+    }
+    setDatafile(datafile, replace = false) {
+        const resolvedDatafile = this.resolveDatafileInput(datafile);
+        if (!resolvedDatafile) {
+            return;
+        }
+        const previousSnapshot = this.getSnapshot();
+        const previousLocale = this.locale;
+        const storedDatafile = !replace && this.datafiles[resolvedDatafile.locale]
+            ? mergeStoredDatafile(this.datafiles[resolvedDatafile.locale], resolvedDatafile)
+            : resolvedDatafile;
+        this.datafiles[storedDatafile.locale] = storedDatafile;
+        if (!this.locale) {
+            this.locale = storedDatafile.locale;
+        }
+        this.emit("datafile_set", previousSnapshot, {
+            datafile: storedDatafile,
+            locale: this.locale,
+            previousLocale,
+        });
+    }
+    setContext(context, replace = false) {
+        const previousSnapshot = this.getSnapshot();
+        const previousContext = this.context;
+        this.context = replace ? context : { ...this.context, ...context };
+        this.emit("context_set", previousSnapshot, {
+            context: { ...this.context },
+            previousContext: { ...previousContext },
+        });
+    }
+    getContext() {
+        return { ...this.context };
+    }
+    setLocale(locale) {
+        if (!this.datafiles[locale]) {
+            throw new Error(`Datafile not found for locale: ${locale}`);
+        }
+        const previousSnapshot = this.getSnapshot();
+        const previousLocale = this.locale;
+        this.locale = locale;
+        this.emit("locale_set", previousSnapshot, {
+            locale,
+            previousLocale,
+        });
+    }
+    getLocale() {
+        return this.locale;
+    }
+    getDirection(locale = this.locale) {
+        if (!locale) {
+            return undefined;
+        }
+        return this.getDatafile(locale).direction;
+    }
+    getDatafile(locale = this.locale) {
+        if (!locale) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "missing_locale",
+                message: "Datafile not found: no locale is set",
+                locale: this.locale,
+            });
+            throw new Error("Datafile not found: no locale is set");
+        }
+        const datafile = this.datafiles[locale];
+        if (!datafile) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "missing_datafile",
+                message: "Datafile not found for locale",
+                locale,
+            });
+            throw new Error(`Datafile not found for locale: ${locale}`);
+        }
+        return datafile;
+    }
+    getRevision(locale) {
+        return this.getDatafile(locale || this.locale).revision;
+    }
+    getCurrentLocale(options = {}) {
+        const locale = options.locale || this.locale;
+        if (!locale) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "missing_locale",
+                message: "Locale not set",
+                locale: this.locale,
+            });
+            throw new Error("Locale not set");
+        }
+        return locale;
+    }
+    emitError(diagnostic) {
+        if (this.closed) {
+            return;
+        }
+        const snapshot = this.getSnapshot();
+        const event = {
+            type: "error",
+            version: this.version,
+            snapshot,
+            previousSnapshot: snapshot,
+            diagnostic,
+        };
+        this.listeners.error.slice().forEach((callback) => callback(event));
+    }
+    reportDiagnostic(diagnostic, sourceModuleKey) {
+        this.moduleDiagnosticSubscriptions.slice().forEach((subscription) => {
+            if (subscription.moduleKey === sourceModuleKey) {
+                return;
+            }
+            if (!shouldLog(subscription.logLevel, diagnostic.level)) {
+                return;
+            }
+            subscription.handler(diagnostic);
+        });
+        if (shouldLog(this.logLevel, diagnostic.level)) {
+            if (this.onDiagnostic) {
+                this.onDiagnostic(diagnostic);
+            }
+            else {
+                const method = diagnostic.level === "fatal" || diagnostic.level === "error"
+                    ? "error"
+                    : diagnostic.level === "warn"
+                        ? "warn"
+                        : diagnostic.level === "debug"
+                            ? "debug"
+                            : "info";
+                console[method](LOG_PREFIX, diagnostic.message, diagnostic);
+            }
+        }
+        if (diagnostic.level === "error") {
+            this.emitError(diagnostic);
+        }
+    }
+    resolveDatafileInput(datafile) {
+        try {
+            const parsedDatafile = typeof datafile === "string" ? JSON.parse(datafile) : datafile;
+            if (!isPlainObject(parsedDatafile) || typeof parsedDatafile.locale !== "string") {
+                throw new Error("Datafile must be an object with a string locale.");
+            }
+            return parsedDatafile;
+        }
+        catch (error) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "invalid_datafile",
+                message: "could not parse datafile",
+                originalError: error,
+            });
+            return undefined;
+        }
+    }
+    getDefaultTranslations(locale = this.locale) {
+        if (!locale) {
+            return undefined;
+        }
+        return this.defaultTranslationsByLocale[locale];
+    }
+    getDefaultFormats(locale = this.locale) {
+        if (!locale) {
+            return undefined;
+        }
+        return this.defaultFormatsByLocale[locale];
+    }
+    getMessageFromDatafile(messageKey, options = {}, locale = this.getCurrentLocale(options)) {
+        const datafile = this.datafiles[locale];
+        if (!datafile) {
+            return undefined;
+        }
+        const evaluationContext = {
+            ...this.context,
+            ...(options.context || {}),
+        };
+        const message = datafile.messages[messageKey];
+        const overrides = (message === null || message === void 0 ? void 0 : message.overrides) || [];
+        for (let index = 0; index < overrides.length; index++) {
+            const override = overrides[index];
+            const matchesConditions = (0, conditions_1.evaluateCondition)(override.conditions, {
+                context: evaluationContext,
+                segments: datafile.segments,
+                resolveFlag: this.resolveFlag,
+                resolveVariation: this.resolveVariation,
+            });
+            const matchesSegments = (0, conditions_1.evaluateGroupSegment)(override.segments, {
+                context: evaluationContext,
+                segments: datafile.segments,
+                resolveFlag: this.resolveFlag,
+                resolveVariation: this.resolveVariation,
+            });
+            const matched = matchesConditions && matchesSegments;
+            if (matched) {
+                const diagnostic = {
+                    level: "debug",
+                    code: "message_override_matched",
+                    message: "Message override matched",
+                    locale,
+                    messageKey,
+                    overrideKey: override.key,
+                };
+                this.reportDiagnostic(diagnostic);
+                return override.translation;
+            }
+        }
+        return datafile.translations[messageKey];
+    }
+    getMessageMeta(messageKey, locale = this.getCurrentLocale()) {
+        var _a, _b;
+        const datafile = this.datafiles[locale];
+        return (_b = (_a = datafile === null || datafile === void 0 ? void 0 : datafile.messages) === null || _a === void 0 ? void 0 : _a[messageKey]) === null || _b === void 0 ? void 0 : _b.meta;
+    }
+    getMessageDefinition(messageKey, locale = this.getCurrentLocale()) {
+        var _a;
+        const datafile = this.datafiles[locale];
+        return (_a = datafile === null || datafile === void 0 ? void 0 : datafile.messages) === null || _a === void 0 ? void 0 : _a[messageKey];
+    }
+    reportDeprecatedMessage(messageKey, message, locale = this.getCurrentLocale()) {
+        if (!message.deprecated) {
+            return;
+        }
+        this.reportDiagnostic({
+            level: "warn",
+            code: "deprecated_message",
+            message: "Deprecated message evaluated",
+            locale,
+            messageKey,
+            deprecationWarning: message.deprecationWarning,
+            source: "translation",
+        });
+    }
+    resolveMessage(messageKey, defaultTranslation, options = {}) {
+        const locale = this.getCurrentLocale(options);
+        const isMissing = (value) => typeof value === "undefined";
+        let translated;
+        if (messageKey) {
+            translated = this.getMessageFromDatafile(messageKey, options, locale);
+            if (isMissing(translated)) {
+                const translations = this.getDefaultTranslations(locale);
+                translated = translations ? translations[messageKey] : undefined;
+            }
+        }
+        if (!messageKey && typeof defaultTranslation === "string") {
+            return {
+                locale,
+                source: defaultTranslation,
+                formatted: defaultTranslation,
+                messageKey: undefined,
+            };
+        }
+        if (!isMissing(translated)) {
+            const message = messageKey ? this.getMessageDefinition(messageKey, locale) : undefined;
+            if (messageKey && message) {
+                this.reportDeprecatedMessage(messageKey, message, locale);
+            }
+            return {
+                locale,
+                source: translated,
+                formatted: translated,
+                messageKey,
+            };
+        }
+        if (messageKey) {
+            this.reportDiagnostic({
+                level: "error",
+                code: "missing_translation",
+                message: "Missing translation",
+                locale,
+                messageKey,
+                source: "translation",
+            });
+        }
+        if (typeof defaultTranslation === "string") {
+            return {
+                locale,
+                source: defaultTranslation,
+                formatted: defaultTranslation,
+                messageKey,
+            };
+        }
+        return {
+            locale,
+            source: messageKey || "",
+            formatted: messageKey || "",
+            messageKey,
+        };
+    }
+    emit(type, previousSnapshot, details = {}) {
+        if (this.closed) {
+            return;
+        }
+        this.version += 1;
+        const event = {
+            ...details,
+            type,
+            version: this.version,
+            snapshot: this.getSnapshot(),
+            previousSnapshot,
+        };
+        this.listeners[type].slice().forEach((callback) => callback(event));
+        const changeEvent = {
+            ...event,
+            type: "change",
+        };
+        this.listeners.change.slice().forEach((callback) => callback(changeEvent));
+    }
+    getEvaluationFormats(options = {}, locale = this.getCurrentLocale(options)) {
+        const formats = deepMerge(deepMerge(this.getDefaultFormats(locale), this.datafiles[locale] ? this.datafiles[locale].formats : undefined), options.formats) || {};
+        const numberFormats = {};
+        const dateFormats = {};
+        const timeFormats = {};
+        const dateTimeRangeFormats = {};
+        Object.keys(formats.number || {}).forEach((key) => {
+            var _a;
+            const formatOptions = (_a = formats.number) === null || _a === void 0 ? void 0 : _a[key];
+            if (!formatOptions) {
+                return;
+            }
+            if (formatOptions.style !== "currency") {
+                numberFormats[key] = formatOptions;
+                return;
+            }
+            numberFormats[key] = {
+                ...formatOptions,
+                currency: resolveCurrency(options.currency, formatOptions.currency, this.currency),
+            };
+        });
+        Object.keys(formats.date || {}).forEach((key) => {
+            var _a;
+            const formatOptions = (_a = formats.date) === null || _a === void 0 ? void 0 : _a[key];
+            if (!formatOptions) {
+                return;
+            }
+            dateFormats[key] = {
+                ...formatOptions,
+                timeZone: resolveTimeZone(options.timeZone, formatOptions.timeZone, this.timeZone),
+            };
+        });
+        Object.keys(formats.time || {}).forEach((key) => {
+            var _a;
+            const formatOptions = (_a = formats.time) === null || _a === void 0 ? void 0 : _a[key];
+            if (!formatOptions) {
+                return;
+            }
+            timeFormats[key] = {
+                ...formatOptions,
+                timeZone: resolveTimeZone(options.timeZone, formatOptions.timeZone, this.timeZone),
+            };
+        });
+        Object.keys(formats.dateTimeRange || {}).forEach((key) => {
+            var _a;
+            const formatOptions = (_a = formats.dateTimeRange) === null || _a === void 0 ? void 0 : _a[key];
+            if (!formatOptions) {
+                return;
+            }
+            dateTimeRangeFormats[key] = {
+                ...formatOptions,
+                timeZone: resolveTimeZone(options.timeZone, formatOptions.timeZone, this.timeZone),
+            };
+        });
+        return {
+            ...formats,
+            number: numberFormats,
+            date: dateFormats,
+            time: timeFormats,
+            dateTimeRange: dateTimeRangeFormats,
+        };
+    }
+    getCachedNumberFormat(locale, options) {
+        var cacheKey = JSON.stringify({
+            locale,
+            options,
+        });
+        if (!this.cache.numberFormat[cacheKey]) {
+            this.cache.numberFormat[cacheKey] = new Intl.NumberFormat(locale, options);
+        }
+        return this.cache.numberFormat[cacheKey];
+    }
+    getCachedDateTimeFormat(locale, options) {
+        var cacheKey = JSON.stringify({
+            locale,
+            options,
+        });
+        if (!this.cache.dateTimeFormat[cacheKey]) {
+            this.cache.dateTimeFormat[cacheKey] = new Intl.DateTimeFormat(locale, options);
+        }
+        return this.cache.dateTimeFormat[cacheKey];
+    }
+    getCachedRelativeTimeFormat(locale, options = {}) {
+        var cacheKey = JSON.stringify({
+            locale,
+            options,
+        });
+        if (!this.cache.relativeTimeFormat[cacheKey]) {
+            this.cache.relativeTimeFormat[cacheKey] = new Intl.RelativeTimeFormat(locale, options);
+        }
+        return this.cache.relativeTimeFormat[cacheKey];
+    }
+    createModuleApi(module) {
+        const moduleKey = this.getModuleApiKey(module);
+        const setFlagResolver = (resolver) => {
+            this.setFlagResolver(resolver);
+        };
+        const setVariationResolver = (resolver) => {
+            this.setVariationResolver(resolver);
+        };
+        const getRevision = (locale) => {
+            return this.getRevision(locale);
+        };
+        const onDiagnostic = (handler, options = {}) => {
+            const subscription = {
+                moduleKey,
+                handler,
+                logLevel: options.logLevel || "info",
+            };
+            this.moduleDiagnosticSubscriptions.push(subscription);
+            return () => {
+                this.moduleDiagnosticSubscriptions = this.moduleDiagnosticSubscriptions.filter((currentSubscription) => currentSubscription !== subscription);
+            };
+        };
+        const reportDiagnostic = (diagnostic) => {
+            const moduleDiagnostic = { ...diagnostic };
+            if (module.name) {
+                moduleDiagnostic.module = module.name;
+            }
+            this.reportDiagnostic(moduleDiagnostic, moduleKey);
+        };
+        return {
+            setFlagResolver,
+            setVariationResolver,
+            getRevision,
+            onDiagnostic,
+            reportDiagnostic,
+        };
+    }
+    getModuleApiKey(module) {
+        if (module.name) {
+            return `name:${module.name}`;
+        }
+        const moduleWithApiKey = module;
+        if (!moduleWithApiKey.__messagevisorModuleApiKey) {
+            moduleWithApiKey.__messagevisorModuleApiKey = `anonymous:${++this.moduleApiId}`;
+        }
+        return moduleWithApiKey.__messagevisorModuleApiKey;
+    }
+    getModuleApi(module) {
+        const key = this.getModuleApiKey(module);
+        const existingApi = this.moduleApis[key];
+        if (existingApi) {
+            return existingApi;
+        }
+        const api = this.createModuleApi(module);
+        this.moduleApis[key] = api;
+        return api;
+    }
+    runModuleSetup(module) {
+        if (!module.setup) {
+            return;
+        }
+        module.setup(this.getModuleApi(module));
+    }
+    clearModuleDiagnosticSubscriptions(module) {
+        const moduleKey = this.getModuleApiKey(module);
+        this.moduleDiagnosticSubscriptions = this.moduleDiagnosticSubscriptions.filter((subscription) => subscription.moduleKey !== moduleKey);
+        delete this.moduleApis[moduleKey];
+    }
+    runTransforms(translation, payload) {
+        var _a;
+        let currentTranslation = translation;
+        for (const module of this.modules) {
+            const nextTranslation = (_a = module.transform) === null || _a === void 0 ? void 0 : _a.call(module, {
+                ...payload,
+                translation: currentTranslation,
+            }, this.getModuleApi(module));
+            if (typeof nextTranslation !== "undefined") {
+                currentTranslation = nextTranslation;
+            }
+        }
+        return currentTranslation;
+    }
+    runFormats(translation, values, payload) {
+        let currentTranslation = translation;
+        for (const module of this.modules) {
+            if (!module.format) {
+                continue;
+            }
+            try {
+                const nextTranslation = module.format({
+                    ...payload,
+                    translation: currentTranslation,
+                    values,
+                }, this.getModuleApi(module));
+                if (typeof nextTranslation !== "undefined") {
+                    currentTranslation = nextTranslation;
+                }
+            }
+            catch (error) {
+                this.reportDiagnostic({
+                    level: "error",
+                    code: "invalid_message",
+                    message: "Unable to format message",
+                    locale: payload.locale,
+                    messageKey: payload.messageKey,
+                    source: payload.source,
+                    originalError: error,
+                });
+                throw error;
+            }
+        }
+        return currentTranslation;
+    }
+    formatMessageInternal(message, values, options = {}) {
+        const locale = this.getCurrentLocale(options);
+        const formats = this.getEvaluationFormats(options, locale);
+        const translation = this.runFormats(message, values, {
+            locale,
+            source: "formatMessage",
+            meta: undefined,
+            formats,
+            moduleOptions: options.moduleOptions,
+        });
+        return this.runTransforms(translation, {
+            locale,
+            source: "formatMessage",
+            meta: undefined,
+        });
+    }
+    translate(messageKey, values, options = {}) {
+        const rawMessage = this.getRawTranslation(messageKey, options);
+        const locale = this.getCurrentLocale(options);
+        const formats = this.getEvaluationFormats(options, locale);
+        const meta = this.getMessageMeta(messageKey, locale);
+        const translation = this.runFormats(rawMessage, values, {
+            locale,
+            source: "translation",
+            messageKey,
+            meta,
+            formats,
+            moduleOptions: options.moduleOptions,
+        });
+        return this.runTransforms(translation, {
+            locale,
+            source: "translation",
+            messageKey,
+            meta,
+        });
+    }
+    t(messageKey, values, options = {}) {
+        if (values === undefined) {
+            return this.translate(messageKey, undefined, options);
+        }
+        return this.translate(messageKey, values, options);
+    }
+    getRawTranslation(messageKey, options = {}) {
+        return this.resolveMessage(messageKey, options.defaultTranslation, options).formatted;
+    }
+    formatMessage(message, values, options = {}) {
+        return this.formatMessageInternal(message, values, options);
+    }
+    async close() {
+        if (this.closePromise) {
+            return this.closePromise;
+        }
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        Object.keys(this.listeners).forEach((eventName) => {
+            this.listeners[eventName] = [];
+        });
+        this.moduleDiagnosticSubscriptions = [];
+        this.moduleApis = {};
+        this.closePromise = this.closeModules();
+        return this.closePromise;
+    }
+    async closeModules() {
+        const errors = [];
+        const modulesToClose = [...this.modules].reverse();
+        for (const module of modulesToClose) {
+            if (!module.close) {
+                continue;
+            }
+            try {
+                await module.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.modules = [];
+        if (errors.length > 0) {
+            throw new MessagevisorCloseError("One or more Messagevisor modules failed to close.", errors);
+        }
+    }
+    formatNumber(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.number) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        const finalOptions = { ...(formatOptions || {}) };
+        if (finalOptions.style === "currency") {
+            finalOptions.currency = resolveCurrency(options.currency, finalOptions.currency, this.currency);
+        }
+        return this.getCachedNumberFormat(locale, finalOptions).format(value);
+    }
+    formatNumberToParts(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.number) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        const finalOptions = { ...(formatOptions || {}) };
+        if (finalOptions.style === "currency") {
+            finalOptions.currency = resolveCurrency(options.currency, finalOptions.currency, this.currency);
+        }
+        return this.getCachedNumberFormat(locale, finalOptions).formatToParts(value);
+    }
+    formatDate(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.date) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        return this.getCachedDateTimeFormat(locale, resolveDateTimeOptions(formatOptions, options, this.timeZone)).format(new Date(value));
+    }
+    formatDateToParts(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.date) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        return this.getCachedDateTimeFormat(locale, resolveDateTimeOptions(formatOptions, options, this.timeZone)).formatToParts(new Date(value));
+    }
+    formatTime(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.time) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        return this.getCachedDateTimeFormat(locale, resolveDateTimeOptions(formatOptions, options, this.timeZone)).format(new Date(value));
+    }
+    formatTimeToParts(value, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.time) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        return this.getCachedDateTimeFormat(locale, resolveDateTimeOptions(formatOptions, options, this.timeZone)).formatToParts(new Date(value));
+    }
+    formatDateTimeRange(start, end, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.dateTimeRange) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        const formatter = this.getCachedDateTimeFormat(locale, resolveDateTimeOptions(formatOptions, options, this.timeZone));
+        const rangeFormatter = formatter;
+        if (rangeFormatter.formatRange) {
+            return rangeFormatter.formatRange(new Date(start), new Date(end));
+        }
+        return `${formatter.format(new Date(start))} - ${formatter.format(new Date(end))}`;
+    }
+    formatRelativeTime(value, unit, presetOrOptions, options = {}) {
+        var _a;
+        const locale = this.getCurrentLocale(options);
+        const evaluationFormats = this.getEvaluationFormats(options, locale);
+        const formatOptions = typeof presetOrOptions === "string"
+            ? (_a = evaluationFormats.relative) === null || _a === void 0 ? void 0 : _a[presetOrOptions]
+            : presetOrOptions;
+        return this.getCachedRelativeTimeFormat(locale, formatOptions).format(value, unit);
+    }
+    formatPlural(value, options = {}) {
+        const { locale: optionLocale, ...pluralOptions } = options;
+        const locale = this.getCurrentLocale({ locale: optionLocale });
+        var cacheKey = JSON.stringify({
+            locale,
+            options: pluralOptions,
+        });
+        if (!this.cache.pluralRules[cacheKey]) {
+            this.cache.pluralRules[cacheKey] = new Intl.PluralRules(locale, pluralOptions);
+        }
+        return this.cache.pluralRules[cacheKey].select(value);
+    }
+    formatList(values, options = {}) {
+        const { locale: optionLocale, ...listOptions } = options || {};
+        const locale = this.getCurrentLocale({ locale: optionLocale });
+        var cacheKey = JSON.stringify({
+            locale,
+            options: listOptions,
+        });
+        var ListFormat = Intl.ListFormat;
+        if (!ListFormat) {
+            this.reportDiagnostic({
+                level: "warn",
+                code: "unsupported_formatter",
+                message: "Intl.ListFormat is not available in this environment.",
+                locale,
+            });
+            return values.join(", ");
+        }
+        if (!this.cache.listFormat[cacheKey]) {
+            this.cache.listFormat[cacheKey] = new ListFormat(locale, listOptions);
+        }
+        return this.cache.listFormat[cacheKey].format(values);
+    }
+    formatListToParts(values, options = {}) {
+        const { locale: optionLocale, ...listOptions } = options || {};
+        const locale = this.getCurrentLocale({ locale: optionLocale });
+        var cacheKey = JSON.stringify({
+            locale,
+            options: listOptions,
+        });
+        var ListFormat = Intl.ListFormat;
+        if (!ListFormat) {
+            this.reportDiagnostic({
+                level: "warn",
+                code: "unsupported_formatter",
+                message: "Intl.ListFormat is not available in this environment.",
+                locale,
+            });
+            return values;
+        }
+        if (!this.cache.listFormat[cacheKey]) {
+            this.cache.listFormat[cacheKey] = new ListFormat(locale, listOptions);
+        }
+        if (typeof this.cache.listFormat[cacheKey].formatToParts !== "function") {
+            return values;
+        }
+        return this.cache.listFormat[cacheKey].formatToParts(values);
+    }
+    formatDisplayName(value, options = {}) {
+        const { locale: optionLocale, ...displayNameOptions } = options || {};
+        const locale = this.getCurrentLocale({ locale: optionLocale });
+        var cacheKey = JSON.stringify({
+            locale,
+            options: displayNameOptions,
+        });
+        var DisplayNames = Intl.DisplayNames;
+        if (!DisplayNames) {
+            this.reportDiagnostic({
+                level: "warn",
+                code: "unsupported_formatter",
+                message: "Intl.DisplayNames is not available in this environment.",
+                locale,
+            });
+            return displayNameOptions && displayNameOptions.fallback === "none" ? undefined : value;
+        }
+        if (!this.cache.displayNames[cacheKey]) {
+            this.cache.displayNames[cacheKey] = new DisplayNames(locale, displayNameOptions);
+        }
+        return this.cache.displayNames[cacheKey].of(value);
+    }
+}
+exports.Messagevisor = Messagevisor;
+function createMessagevisor(options = {}) {
+    return new Messagevisor(options);
+}
+//# sourceMappingURL=instance.js.map