@backstage/core-plugin-api 1.6.0-next.3 → 1.7.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @backstage/core-plugin-api
 
+## 1.7.0-next.0
+
+### Minor Changes
+
+- 322bbcae24: Removed the exprimental plugin configuration API. The `__experimentalReconfigure()` from the plugin options as well as the `__experimentalConfigure()` method on plugin instances have both been removed.
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/config@1.1.0
+  - @backstage/types@1.1.1
+  - @backstage/version-bridge@1.0.5
+
+## 1.6.0
+
+### Minor Changes
+
+- 18619f793c94: Added the optional `expiresAt` field that may now be part of a `BackstageIdentityResponse`.
+- 6e30769cc627: Introduced experimental support for internationalization.
+
+### Patch Changes
+
+- 406b786a2a2c: Mark package as being free of side effects, allowing more optimized Webpack builds.
+- 8cec7664e146: Removed `@types/node` dependency
+- Updated dependencies
+  - @backstage/config@1.1.0
+  - @backstage/types@1.1.1
+  - @backstage/version-bridge@1.0.5
+
 ## 1.6.0-next.3
 
 ### Patch Changes

package/alpha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backstage/core-plugin-api",
-  "version": "1.6.0-next.3",
+  "version": "1.7.0-next.0",
   "main": "../dist/alpha.esm.js",
   "module": "../dist/alpha.esm.js",
   "types": "../dist/alpha.d.ts"

package/dist/alpha.d.ts

@@ -1,78 +1,394 @@
-import { BackstagePlugin, ApiRef } from '@backstage/core-plugin-api';
-import { ReactNode } from 'react';
-import { i18n } from 'i18next';
+import { TranslationRef as TranslationRef$1, TranslationMessages as TranslationMessages$1 } from '@backstage/core-plugin-api/alpha';
+import { ApiRef } from '@backstage/core-plugin-api';
+import { Observable } from '@backstage/types';
 
 /**
- * Properties for the PluginProvider component.
+ * Represents a collection of messages to be provided for a given translation ref.
  *
  * @alpha
+ * @remarks
+ *
+ * This collection of messages can either be used directly as an override for the
+ * default messages, or it can be used to provide translations for a language by
+ * by being referenced by a {@link TranslationResource}.
  */
-interface PluginOptionsProviderProps {
-    children: ReactNode;
-    plugin?: BackstagePlugin;
+interface TranslationMessages<TId extends string = string, TMessages extends {
+    [key in string]: string;
+} = {
+    [key in string]: string;
+}, TFull extends boolean = boolean> {
+    $$type: '@backstage/TranslationMessages';
+    /** The ID of the translation ref that these messages are for */
+    id: TId;
+    /** Whether or not these messages override all known messages */
+    full: TFull;
+    /** The messages provided for the given translation ref */
+    messages: TMessages;
 }
 /**
- * Contains the plugin configuration.
+ * Options for {@link createTranslationMessages}.
  *
  * @alpha
  */
-declare const PluginProvider: (props: PluginOptionsProviderProps) => JSX.Element;
+interface TranslationMessagesOptions<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TFull extends boolean> {
+    ref: TranslationRef$1<TId, TMessages>;
+    full?: TFull;
+    messages: false extends TFull ? {
+        [key in keyof TMessages]?: string | null;
+    } : {
+        [key in keyof TMessages]: string | null;
+    };
+}
 /**
- * Grab the current entity from the context, throws if the entity has not yet been loaded
- * or is not available.
+ * Creates a collection of messages for a given translation ref.
  *
  * @alpha
  */
-declare function usePluginOptions<TPluginOptions extends {} = {}>(): TPluginOptions;
+declare function createTranslationMessages<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TFull extends boolean>(options: TranslationMessagesOptions<TId, TMessages, TFull>): TranslationMessages<TId, TMessages, TFull>;
 
 /** @alpha */
-interface TranslationRefConfig<Messages extends Record<keyof Messages, string>> {
-    id: string;
-    messages: Messages;
-    lazyResources?: Record<string, () => Promise<{
-        messages: Messages;
-    }>>;
-    resources?: Record<string, Messages>;
+interface TranslationResource<TId extends string = string> {
+    $$type: '@backstage/TranslationResource';
+    id: TId;
 }
 /** @alpha */
-interface TranslationRef<Messages extends Record<keyof Messages, string> = Record<string, string>> {
-    getId(): string;
-    getDefaultMessages(): Messages;
-    getResources(): Record<string, Messages> | undefined;
-    getLazyResources(): Record<string, () => Promise<{
-        messages: Messages;
-    }>> | undefined;
+interface TranslationResourceOptions<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: TranslationMessages$1<TId> | {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}> {
+    ref: TranslationRef$1<TId, TMessages>;
+    translations: TTranslations;
 }
 /** @alpha */
-type TranslationOptions<Messages extends Record<keyof Messages, string> = Record<string, string>> = Messages;
+declare function createTranslationResource<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: TranslationMessages$1<TId> | {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}>(options: TranslationResourceOptions<TId, TMessages, TTranslations>): TranslationResource<TId>;
 
 /** @alpha */
-declare class TranslationRefImpl<Messages extends Record<keyof Messages, string>> implements TranslationRef<Messages> {
-    private readonly config;
-    static create<Messages extends Record<keyof Messages, string>>(config: TranslationRefConfig<Messages>): TranslationRefImpl<Messages>;
-    getId(): string;
-    getDefaultMessages(): Messages;
-    getLazyResources(): Record<string, () => Promise<{
-        messages: Messages;
-    }>> | undefined;
-    getResources(): Record<string, Messages> | undefined;
-    toString(): string;
-    private constructor();
+interface TranslationRef<TId extends string = string, TMessages extends {
+    [key in string]: string;
+} = {
+    [key in string]: string;
+}> {
+    $$type: '@backstage/TranslationRef';
+    id: TId;
+    T: TMessages;
+}
+/** @alpha */
+interface TranslationRefOptions<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}> {
+    id: TId;
+    messages: TMessages;
+    translations?: TTranslations;
 }
 /** @alpha */
-declare const createTranslationRef: <Messages extends Record<keyof Messages, string> = {}>(config: TranslationRefConfig<Messages>) => TranslationRef<Messages>;
+declare function createTranslationRef<TId extends string, const TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}>(config: TranslationRefOptions<TId, TMessages, TTranslations>): TranslationRef<TId, TMessages>;
 
+/**
+ * Base translation options.
+ *
+ * @alpha
+ */
+interface BaseOptions {
+    interpolation?: {
+        /** Whether to HTML escape provided values, defaults to false  */
+        escapeValue?: boolean;
+    };
+}
+/**
+ * All pluralization suffixes supported by i18next
+ *
+ * @ignore
+ */
+type TranslationPlural = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+/**
+ * A mapping of i18n formatting types to their corresponding types and options.
+ * @ignore
+ */
+type I18nextFormatMap = {
+    number: {
+        type: number;
+        options: Intl.NumberFormatOptions;
+    };
+    currency: {
+        type: number;
+        options: Intl.NumberFormatOptions;
+    };
+    datetime: {
+        type: Date;
+        options: Intl.DateTimeFormatOptions;
+    };
+    relativetime: {
+        type: number;
+        options: {
+            range?: Intl.RelativeTimeFormatUnit;
+        } & Intl.RelativeTimeFormatOptions;
+    };
+    list: {
+        type: string[];
+        options: Intl.ListFormatOptions;
+    };
+};
+/**
+ * Extracts all pluralized keys from the message map.
+ *
+ * @example
+ * ```
+ * { foo: 'foo', bar_one: 'bar', bar_other: 'bars' } -> 'bar'
+ * ```
+ *
+ * @ignore
+ */
+type PluralKeys<TMessages extends {
+    [key in string]: string;
+}> = {
+    [Key in keyof TMessages]: Key extends `${infer K}_${TranslationPlural}` ? K : never;
+}[keyof TMessages];
+/**
+ * Collapses a message map into normalized keys with union values.
+ *
+ * @example
+ * ```
+ * { foo_one: 'foo', foo_other: 'foos' } -> { foo: 'foo' | 'foos' }
+ * ```
+ *
+ * @ignore
+ */
+type CollapsedMessages<TMessages extends {
+    [key in string]: string;
+}> = {
+    [key in keyof TMessages as key extends `${infer K}_${TranslationPlural}` ? K : key]: TMessages[key];
+};
+/**
+ * Helper type that expands type hints
+ *
+ * @ignore
+ */
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/**
+ * Helper type that expands type hints recursively
+ *
+ * @ignore
+ */
+type ExpandRecursive<T> = T extends infer O ? {
+    [K in keyof O]: ExpandRecursive<O[K]>;
+} : never;
+/**
+ * Trim away whitespace
+ *
+ * @ignore
+ */
+type Trim<T> = T extends ` ${infer U}` ? Trim<U> : T extends `${infer U} ` ? Trim<U> : T;
+/**
+ * Extracts the key and format from a replacement string.
+ *
+ * @example
+ * ```
+ * 'foo, number' -> { foo: number }, 'foo' -> { foo: undefined }
+ * ```
+ */
+type ExtractFormat<Replacement extends string> = Replacement extends `${infer Key},${infer FullFormat}` ? {
+    [key in Trim<Key>]: Lowercase<Trim<FullFormat extends `${infer Format}(${string})${string}` ? Format : FullFormat>>;
+} : {
+    [key in Trim<Replacement>]: undefined;
+};
+/**
+ * Expand the keys in a flat map to nested objects.
+ *
+ * @example
+ * ```
+ * { 'a.b': 'foo', 'a.c': 'bar' } -> { a: { b: 'foo', c: 'bar' }
+ * ```
+ *
+ * @ignore
+ */
+type ExpandKeys<TMap extends {}> = {
+    [Key in keyof TMap as Key extends `${infer Prefix}.${string}` ? Prefix : Key]: Key extends `${string}.${infer Rest}` ? ExpandKeys<{
+        [key in Rest]: TMap[Key];
+    }> : TMap[Key];
+};
+/**
+ * Extracts all option keys and their format from a message string.
+ *
+ * @example
+ * ```
+ * 'foo {{bar}} {{baz, number}}' -> { 'bar': undefined, 'baz': 'number' }
+ * ```
+ *
+ * @ignore
+ */
+type ReplaceFormatsFromMessage<TMessage> = TMessage extends `${string}{{${infer Replacement}}}${infer Tail}` ? ExpandKeys<ExtractFormat<Replacement>> & ReplaceFormatsFromMessage<Tail> : {};
+/**
+ * Generates the replace options structure
+ *
+ * @ignore
+ */
+type ReplaceOptionsFromFormats<TFormats extends {}> = {
+    [Key in keyof TFormats]: TFormats[Key] extends keyof I18nextFormatMap ? I18nextFormatMap[TFormats[Key]]['type'] : TFormats[Key] extends {} ? Expand<ReplaceOptionsFromFormats<TFormats[Key]>> : string;
+};
+/**
+ * Generates the formatParams options structure
+ *
+ * @ignore
+ */
+type ReplaceFormatParamsFromFormats<TFormats extends {}> = {
+    [Key in keyof TFormats]?: TFormats[Key] extends keyof I18nextFormatMap ? I18nextFormatMap[TFormats[Key]]['options'] : TFormats[Key] extends {} ? Expand<ReplaceFormatParamsFromFormats<TFormats[Key]>> : undefined;
+};
+/**
+ * Extracts all nesting keys from a message string.
+ *
+ * @example
+ * ```
+ * 'foo $t(bar) $t(baz)' -> 'bar' | 'baz'
+ * ```
+ *
+ * @ignore
+ */
+type NestingKeysFromMessage<TMessage extends string> = TMessage extends `${string}$t(${infer Key})${infer Tail}` ? Trim<Key> | NestingKeysFromMessage<Tail> : never;
+/**
+ * Find all referenced keys, given a starting key and the full set of messages.
+ *
+ * This will only discover keys up to 3 levels deep.
+ *
+ * @example
+ * ```
+ * <'x', { x: '$t(y) $t(z)', y: 'y', z: '$t(w)', w: 'w', foo: 'foo' }> -> 'x' | 'y' | 'z' | 'w'
+ * ```
+ *
+ * @ignore
+ */
+type NestedMessageKeys<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestedMessageKeys2<NestingKeysFromMessage<TMessages[TKey]>, TMessages>;
+type NestedMessageKeys2<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestedMessageKeys3<NestingKeysFromMessage<TMessages[TKey]>, TMessages>;
+type NestedMessageKeys3<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestingKeysFromMessage<TMessages[TKey]>;
+/**
+ * Converts a union type to an intersection type.
+ *
+ * @example
+ * ```
+ * { foo: 'foo' } | { bar: 'bar' } -> { foo: 'foo' } & { bar: 'bar' }
+ * ```
+ *
+ * @ignore
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Collects different types of options into a single object
+ *
+ * @ignore
+ */
+type CollectOptions<TCount extends {
+    count?: number;
+}, TFormats extends {}> = TCount & (keyof Omit<TFormats, 'count'> extends never ? {} : (Expand<Omit<ReplaceOptionsFromFormats<TFormats>, 'count'>> | {
+    replace: Expand<Omit<ReplaceOptionsFromFormats<TFormats>, 'count'>>;
+}) & {
+    formatParams?: Expand<ReplaceFormatParamsFromFormats<TFormats>>;
+});
+/**
+ * Helper type to only require options argument if needed
+ *
+ * @ignore
+ */
+type OptionArgs<TOptions extends {}> = keyof TOptions extends never ? [options?: BaseOptions] : [options: BaseOptions & TOptions];
+/**
+ * @ignore
+ */
+type TranslationFunctionOptions<TKeys extends keyof TMessages, // All normalized message keys to be considered, i.e. included nested ones
+TPluralKeys extends keyof TMessages, // All keys in the message map that are pluralized
+TMessages extends {
+    [key in string]: string;
+}> = OptionArgs<Expand<CollectOptions<TKeys & TPluralKeys extends never ? {} : {
+    count: number;
+}, ExpandRecursive<UnionToIntersection<ReplaceFormatsFromMessage<TMessages[TKeys]>>>>>>;
 /** @alpha */
-declare const useTranslationRef: <Messages extends Record<keyof Messages, string>>(translationRef: TranslationRef<Messages>) => <Tkey extends keyof Messages>(key: Tkey, options?: TranslationOptions) => Messages[Tkey];
+interface TranslationFunction<TMessages extends {
+    [key in string]: string;
+}> {
+    <TKey extends keyof CollapsedMessages<TMessages>>(key: TKey, ...[args]: TranslationFunctionOptions<NestedMessageKeys<TKey, CollapsedMessages<TMessages>>, PluralKeys<TMessages>, CollapsedMessages<TMessages>>): CollapsedMessages<TMessages>[TKey];
+}
+/** @alpha */
+type TranslationSnapshot<TMessages extends {
+    [key in string]: string;
+}> = {
+    ready: false;
+} | {
+    ready: true;
+    t: TranslationFunction<TMessages>;
+};
+/** @alpha */
+type TranslationApi = {
+    getTranslation<TMessages extends {
+        [key in string]: string;
+    }>(translationRef: TranslationRef<string, TMessages>): TranslationSnapshot<TMessages>;
+    translation$<TMessages extends {
+        [key in string]: string;
+    }>(translationRef: TranslationRef<string, TMessages>): Observable<TranslationSnapshot<TMessages>>;
+};
+/**
+ * @alpha
+ */
+declare const translationApiRef: ApiRef<TranslationApi>;
 
 /** @alpha */
-type AppTranslationApi = {
-    getI18n(): i18n;
-    addResourcesByRef<Messages extends Record<string, string>>(translationRef: TranslationRef<Messages>): void;
+type AppLanguageApi = {
+    getAvailableLanguages(): {
+        languages: string[];
+    };
+    setLanguage(language?: string): void;
+    getLanguage(): {
+        language: string;
+    };
+    language$(): Observable<{
+        language: string;
+    }>;
 };
 /**
  * @alpha
  */
-declare const appTranslationApiRef: ApiRef<AppTranslationApi>;
+declare const appLanguageApiRef: ApiRef<AppLanguageApi>;
+
+/** @alpha */
+declare const useTranslationRef: <TMessages extends {
+    [x: string]: string;
+}>(translationRef: TranslationRef<string, TMessages>) => {
+    t: TranslationFunction<TMessages>;
+};
 
-export { AppTranslationApi, PluginOptionsProviderProps, PluginProvider, TranslationOptions, TranslationRef, TranslationRefConfig, TranslationRefImpl, appTranslationApiRef, createTranslationRef, usePluginOptions, useTranslationRef };
+export { AppLanguageApi, TranslationApi, TranslationFunction, TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, TranslationSnapshot, appLanguageApiRef, createTranslationMessages, createTranslationRef, createTranslationResource, translationApiRef, useTranslationRef };

package/dist/alpha.esm.js

@@ -1,46 +1,178 @@
-import { u as useApi } from './esm/usePluginOptions-6dc02fab.esm.js';
-export { P as PluginProvider, y as usePluginOptions } from './esm/usePluginOptions-6dc02fab.esm.js';
-import { useTranslation } from 'react-i18next';
+import { useState, useMemo, useCallback, useEffect, useRef } from 'react';
+import { u as useApi, r as errorApiRef } from './esm/StorageApi-2de4f480.esm.js';
 import { createApiRef } from '@backstage/core-plugin-api';
-import 'react';
 import '@backstage/version-bridge';
 
+function createTranslationMessages(options) {
+  return {
+    $$type: "@backstage/TranslationMessages",
+    id: options.ref.id,
+    full: Boolean(options.full),
+    messages: options.messages
+  };
+}
+
+function createTranslationResource(options) {
+  return {
+    $$type: "@backstage/TranslationResource",
+    version: "v1",
+    id: options.ref.id,
+    resources: Object.entries(options.translations).map(
+      ([language, loader]) => ({
+        language,
+        loader: () => loader().then((m) => {
+          const value = m.default;
+          return {
+            messages: (value == null ? void 0 : value.$$type) === "@backstage/TranslationMessages" ? value.messages : value
+          };
+        })
+      })
+    )
+  };
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _id, _messages, _resources;
 class TranslationRefImpl {
-  constructor(config) {
-    this.config = config;
+  constructor(options) {
+    __privateAdd(this, _id, void 0);
+    __privateAdd(this, _messages, void 0);
+    __privateAdd(this, _resources, void 0);
+    __publicField(this, "$$type", "@backstage/TranslationRef");
+    __publicField(this, "version", "v1");
+    __privateSet(this, _id, options.id);
+    __privateSet(this, _messages, options.messages);
   }
-  static create(config) {
-    return new TranslationRefImpl(config);
+  get id() {
+    return __privateGet(this, _id);
   }
-  getId() {
-    return this.config.id;
+  get T() {
+    throw new Error("Not implemented");
   }
   getDefaultMessages() {
-    return this.config.messages;
+    return __privateGet(this, _messages);
   }
-  getLazyResources() {
-    return this.config.lazyResources;
+  setDefaultResource(resources) {
+    __privateSet(this, _resources, resources);
   }
-  getResources() {
-    return this.config.resources;
+  getDefaultResource() {
+    return __privateGet(this, _resources);
   }
   toString() {
-    return `TranslationRef(${this.getId()})`;
+    return `TranslationRef{id=${this.id}}`;
+  }
+}
+_id = new WeakMap();
+_messages = new WeakMap();
+_resources = new WeakMap();
+function createTranslationRef(config) {
+  const ref = new TranslationRefImpl(config);
+  if (config.translations) {
+    ref.setDefaultResource(
+      createTranslationResource({
+        ref,
+        translations: config.translations
+      })
+    );
   }
+  return ref;
 }
-const createTranslationRef = (config) => TranslationRefImpl.create(config);
 
-const appTranslationApiRef = createApiRef({
-  id: "core.apptranslation"
+const translationApiRef = createApiRef({
+  id: "core.translation"
 });
 
+const appLanguageApiRef = createApiRef({
+  id: "core.applanguage"
+});
+
+const loggedRefs = /* @__PURE__ */ new WeakSet();
 const useTranslationRef = (translationRef) => {
-  const appTranslationApi = useApi(appTranslationApiRef);
-  appTranslationApi.addResourcesByRef(translationRef);
-  const { t } = useTranslation(translationRef.getId());
-  const defaulteMessage = translationRef.getDefaultMessages();
-  return (key, options) => t(key, defaulteMessage[key], options);
+  const errorApi = useApi(errorApiRef);
+  const translationApi = useApi(translationApiRef);
+  const [snapshot, setSnapshot] = useState(
+    () => translationApi.getTranslation(translationRef)
+  );
+  const observable = useMemo(
+    () => translationApi.translation$(translationRef),
+    [translationApi, translationRef]
+  );
+  const onError = useCallback(
+    (error) => {
+      if (!loggedRefs.has(translationRef)) {
+        const errMsg = `Failed to load translation resource '${translationRef.id}'; caused by ${error}`;
+        console.error(errMsg);
+        errorApi.post(new Error(errMsg));
+        loggedRefs.add(translationRef);
+      }
+    },
+    [errorApi, translationRef]
+  );
+  useEffect(() => {
+    const subscription = observable.subscribe({
+      next(next) {
+        if (next.ready) {
+          setSnapshot(next);
+        }
+      },
+      error(error) {
+        onError(error);
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [observable, onError]);
+  const initialRenderRef = useRef(true);
+  useEffect(() => {
+    if (initialRenderRef.current) {
+      initialRenderRef.current = false;
+    } else {
+      setSnapshot(translationApi.getTranslation(translationRef));
+    }
+  }, [translationApi, translationRef]);
+  if (!snapshot.ready) {
+    throw new Promise((resolve) => {
+      const subscription = observable.subscribe({
+        next(next) {
+          if (next.ready) {
+            subscription.unsubscribe();
+            resolve();
+          }
+        },
+        error(error) {
+          subscription.unsubscribe();
+          onError(error);
+          resolve();
+        }
+      });
+    });
+  }
+  return { t: snapshot.t };
 };
 
-export { TranslationRefImpl, appTranslationApiRef, createTranslationRef, useTranslationRef };
+export { appLanguageApiRef, createTranslationMessages, createTranslationRef, createTranslationResource, translationApiRef, useTranslationRef };
 //# sourceMappingURL=alpha.esm.js.map