gt-react 10.19.15 → 10.19.17

package/dist/browser.d.mts

@@ -0,0 +1,701 @@
+import { GT } from "generaltranslation";
+import { JSX, ReactNode } from "react";
+
+//#region ../format/dist/types-COaQnqVZ.d.cts
+//#region src/locales/customLocaleMapping.d.ts
+type CustomMapping = Record<string, string | Partial<LocaleProperties>>; //#endregion
+//#region src/locales/getLocaleProperties.d.ts
+type LocaleProperties = {
+  code: string;
+  name: string;
+  nativeName: string;
+  languageCode: string;
+  languageName: string;
+  nativeLanguageName: string;
+  nameWithRegionCode: string;
+  nativeNameWithRegionCode: string;
+  regionCode: string;
+  regionName: string;
+  nativeRegionName: string;
+  scriptCode: string;
+  scriptName: string;
+  nativeScriptName: string;
+  maximizedCode: string;
+  maximizedName: string;
+  nativeMaximizedName: string;
+  minimizedCode: string;
+  minimizedName: string;
+  nativeMinimizedName: string;
+  emoji: string;
+}; //#endregion
+//#region src/locales/getRegionProperties.d.ts
+//#endregion
+//#region src/types-dir/jsx/variables.d.ts
+type VariableType = 'v' | 'n' | 'd' | 'c' | 'rt';
+/**
+ * Variables are used to store the variable name and type.
+ */
+type Variable = {
+  k: string;
+  i?: number;
+  v?: VariableType;
+}; //#endregion
+//#region src/types-dir/jsx/content.d.ts
+/**
+ * Map of data-_gt properties to their corresponding React props
+ */
+declare const HTML_CONTENT_PROPS: {
+  readonly pl: "placeholder";
+  readonly ti: "title";
+  readonly alt: "alt";
+  readonly arl: "aria-label";
+  readonly arb: "aria-labelledby";
+  readonly ard: "aria-describedby";
+};
+type HtmlContentPropKeysRecord = Partial<Record<keyof typeof HTML_CONTENT_PROPS, string>>;
+/**
+ * GTProp is an internal property used to contain data for translating and rendering elements.
+ * note, transformations are only read on the server side if they are 'plural' or 'branch'
+ */
+type GTProp = {
+  b?: Record<string, JsxChildren>;
+  t?: 'p' | 'b';
+} & HtmlContentPropKeysRecord;
+type JsxElement = {
+  t?: string;
+  i?: number;
+  d?: GTProp;
+  c?: JsxChildren;
+};
+type JsxChild = string | JsxElement | Variable;
+/**
+ * The format of the string content
+ */
+type StringFormat = 'ICU' | 'I18NEXT' | 'STRING';
+/**
+ * The format of the content.
+ */
+type DataFormat = 'JSX' | StringFormat;
+/**
+ * String format content.
+ */
+/**
+ * A content type representing JSX elements.
+ */
+type JsxChildren = JsxChild | JsxChild[];
+/**
+ * A content type representing ICU messages.
+ */
+//#endregion
+//#region ../i18n/dist/options-D0Lnxv2X.d.cts
+//#region src/translation-functions/types/options.d.ts
+type BaseTranslationOptions = Record<string, unknown>;
+/**
+ * Options for string resolution
+ * Used by the gt() function
+ */
+type InlineTranslationOptions = BaseTranslationOptions & {
+  $context?: string;
+  $id?: string; /** The data format for the message (e.g., 'ICU', 'STRING'). Defaults to 'ICU'. */
+  $format?: StringFormat; /** The locale to use for formatting the message. */
+  $locale?: string;
+  /**
+   * @deprecated use {@link $locale} instead
+   */
+  $_locales?: string | string[];
+  $_hash?: string;
+  $maxChars?: number; /** @deprecated use {@link EncodedTranslationOptions} instead */
+  $_source?: string;
+};
+/**
+ * Options for string resolution
+ * Used by the m() function
+ */
+/**
+ * Options for runtime translation
+ * Used by the tx() function
+ */
+type RuntimeTranslationOptions = {
+  $locale?: string;
+  $format?: DataFormat;
+} & Omit<InlineTranslationOptions, '$id' | '$format'>;
+/**
+ * Options for JSX translation
+ * Used by the resolveJsxTranslation() function
+ */
+type JsxTranslationOptions$1 = {
+  $format?: 'JSX';
+  $context?: string;
+  $id?: string;
+  $_hash?: string;
+};
+/**
+ * Resolution options - options needed to perform a resolution for a given content
+ */
+//#endregion
+//#region ../i18n/dist/localeResolver-CYvrEtm0.d.cts
+/**
+ * TODO: this disagrees with the type in react-core/src/types-dir/config.ts, we need to move this
+ * General Config:
+ * @param defaultLocale - The default locale to use
+ * @param locales - The locales to support
+ * @param customMapping - The custom mapping to use (for aliasing locale codes and other properties)
+ * @param enableI18n - Whether to enable i18n
+ *
+ * Remote Store/Cache Config:
+ * @param projectId - The project id
+ * @param devApiKey - The dev api key
+ * @param _versionId - The version id
+ * @param _branchId - The branch id
+ * @param cacheUrl - The cache url
+ * @param runtimeUrl - The runtime url
+ * @param timeout - The timeout
+ * @param modelProvider - The model provider
+ */
+type GTConfig = {
+  defaultLocale?: string;
+  locales?: string[];
+  customMapping?: CustomMapping;
+  enableI18n?: boolean;
+  projectId?: string;
+  devApiKey?: string;
+  apiKey?: string;
+  _versionId?: string;
+  _branchId?: string;
+  cacheUrl?: string | null;
+  cacheExpiryTime?: number;
+  runtimeUrl?: string | null;
+  modelProvider?: string;
+  localeCookieName?: string;
+  files?: {
+    gt?: {
+      parsingFlags?: {
+        /**
+         * Dev hot reload config, gt-react/browser only.
+         * - `true` enables strings hot reload (jsx handled at runtime via Suspense)
+         * - `{ strings?: boolean; jsx?: boolean }` enables selectively
+         */
+        devHotReload?: boolean | {
+          strings?: boolean;
+          jsx?: boolean;
+        };
+      };
+    };
+  };
+}; //#endregion
+//#region src/i18n-manager/translations-manager/translations-loaders/types.d.ts
+/**
+ * Translations loader function type
+ */
+type TranslationsLoader = (locale: string) => Promise<unknown>; //#endregion
+//#region src/i18n-manager/types.d.ts
+//#endregion
+//#region src/i18n-context/browser-i18n-manager/utils/types.d.ts
+/**
+ * Type for custom getLocale function
+ */
+type GetLocale = () => string;
+/**
+ * Html tag options
+ * @param {boolean} updateHtmlLangTag - Whether to update the html lang tag on locale change
+ * @param {boolean} updateHtmlDirTag - Whether to update the html dir tag on locale change
+ */
+type HtmlTagOptions = {
+  updateHtmlLangTag?: boolean;
+  updateHtmlDirTag?: boolean;
+};
+//#endregion
+//#region src/i18n-context/setup/types.d.ts
+/**
+ * Parameters for the initializing GT
+ * @param {string} params.defaultLocale - The default locale to use
+ * @param {string[]} params.locales - The locales to support
+ * @param {TranslationsLoader} params.loadTranslations - The custom translation loader to use
+ * @param {GetLocale} [params.getLocale] - The function to get the locale
+ * @param {HtmlTagOptions} [params.htmlTagOptions.updateHtmlLangTag] - (true) Whether to update the html lang tag on locale change
+ * @param {HtmlTagOptions} [params.htmlTagOptions.updateHtmlDirTag] - (true) Whether to update the html dir tag on locale change
+ */
+type InitializeGTParams = GTConfig & {
+  loadTranslations?: TranslationsLoader;
+  getLocale?: GetLocale;
+  htmlTagOptions?: HtmlTagOptions;
+};
+//#endregion
+//#region src/i18n-context/setup/bootstrap.d.ts
+/**
+ * Initialization function for react-core library invoked to enable synchronous resolution
+ * @param {InitializeGTParams} params - The parameters for the initialization
+ * @returns {Promise<void>} A promise that resolves when the bootstrap is complete
+ *
+ * @example
+ * import gtConfig from '../gt.config.json';
+ *
+ * async function loadTranslations(locale: string) {
+ *   return (await import(`./_gt/${locale}.json`)).default;
+ * }
+ *
+ * await bootstrap({
+ *   ...gtConfig,
+ *   loadTranslations,
+ * });
+ *
+ * await import('./main.tsx')
+ */
+declare function bootstrap(params: InitializeGTParams): Promise<void>;
+//#endregion
+//#region src/i18n-context/setup/initializeGT.d.ts
+/**
+ * Configure GT for browser runtime. This must be called to setup GT for browser runtime.
+ * @param {InitializeGTParams} config - The configuration for the GT instance
+ */
+declare function initializeGT(params: InitializeGTParams): void;
+//#endregion
+//#region src/i18n-context/functions/branching/GtInternalBranch.d.ts
+type BranchProps = {
+  children?: ReactNode;
+  branch: string | number | boolean | undefined;
+  [key: string]: ReactNode;
+};
+/**
+ * The `<Branch>` component dynamically renders a specified branch of content
+ * or a fallback child component. It allows for flexible content switching
+ * based on the `branch` prop.
+ *
+ * This is the i18n-context version — does not use React Context.
+ */
+declare function Branch({
+  children,
+  branch,
+  ...branches
+}: BranchProps): ReactNode;
+declare namespace Branch {
+  var _gtt: string;
+}
+/**
+ * Equivalent to the `<Branch>` component, but used for auto insertion.
+ */
+declare function GtInternalBranch(props: BranchProps): ReactNode;
+declare namespace GtInternalBranch {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/branching/GtInternalPlural.d.ts
+type PluralProps = {
+  children?: ReactNode;
+  n: number;
+  locales?: string;
+  [key: string]: ReactNode;
+};
+/**
+ * The `<Plural>` component dynamically renders content based on the plural
+ * form of the given number (`n`).
+ *
+ * This is the i18n-context version — uses singleton locale instead of React Context.
+ */
+declare function Plural({
+  children,
+  n,
+  locales: localesProp,
+  ...branches
+}: PluralProps): ReactNode;
+declare namespace Plural {
+  var _gtt: string;
+}
+/**
+ * Equivalent to the `<Plural>` component, but used for auto insertion.
+ */
+declare function GtInternalPlural(props: PluralProps): ReactNode;
+declare namespace GtInternalPlural {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/derivation/GtInternalDerive.d.ts
+type DeriveProps<T extends ReactNode> = {
+  children: T;
+};
+/**
+ * Marks JSX children as derivable by the GT compiler and CLI.
+ *
+ * Use `<Derive>` inside translated JSX when child content is computed from
+ * source code, but should still be discovered during extraction instead of
+ * treated as a runtime interpolation variable. It renders its children
+ * unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing `<Derive>` usage to verify that
+ * each derivable expression can be resolved by the CLI.
+ *
+ * This is the i18n-context version and does not use React Context.
+ */
+declare function Derive<T extends ReactNode>({
+  children
+}: DeriveProps<T>): T;
+declare namespace Derive {
+  var _gtt: string;
+}
+/**
+ * Equivalent to the `<Derive>` component, but used for auto insertion.
+ */
+declare function GtInternalDerive<T extends ReactNode>(props: DeriveProps<T>): T;
+declare namespace GtInternalDerive {
+  var _gtt: string;
+}
+//#endregion
+//#region ../i18n/dist/functions-DI1QpQoC.d.cts
+/**
+ * Synchronous resolution function type
+ * @param {string} message - The message to translate.
+ * @param {InlineTranslationOptions} options - The options for the translation.
+ * @returns {string | undefined} The translated message or undefined if the message is not found.
+ *
+ * @important This is base type for user API
+ *
+ * TODO: next major version, this should be <T extends string | null | undefined>(message: T, options?: InlineTranslationOptions) => T extends string ? string : T;
+ */
+type SyncResolutionFunction = (message: string, options?: InlineTranslationOptions) => string | undefined;
+/**
+ * Synchronous resolution function type
+ * @param {string} message - The message to translate.
+ * @param {InlineTranslationOptions} options - The options for the translation.
+ * @returns {string} The translated message.
+ *
+ * @important This is base type for user API
+ *
+ * TODO: next major version, this should be <T extends string | null | undefined>(message: T, options?: InlineTranslationOptions) => T extends string ? string : T;
+ */
+type SyncResolutionFunctionWithFallback = (message: string, options?: InlineTranslationOptions) => string;
+/**
+ * Type for the gt() function
+ * @param {string} message - The message to translate
+ * @param {InlineTranslationOptions} options - The options for the translation
+ * @returns {string} The translated message
+ * TODO: next major version, remove the "...type" suffix, it's redundant
+ */
+//#endregion
+//#region src/i18n-context/functions/translation/types.d.ts
+/**
+ * Overloaded type for the `t` function.
+ * - Tagged template: t`Hello, ${name}` (transformed by the compiler plugin at build time)
+ * - Function call: t("Hello, {name}", { name: "John" })
+ *
+ * {@link TemplateSyncResolutionFunction}
+ * {@link SyncResolutionFunction}
+ */
+interface StringOrTemplateSyncResolutionFunction {
+  (strings: TemplateStringsArray, ...values: unknown[]): string;
+  (message: string, options?: InlineTranslationOptions): string;
+}
+//#endregion
+//#region src/i18n-context/functions/translation/t.d.ts
+/**
+ * NOTE: t() is the only function exported from the 'gt-react' entry point.
+ * All other functions in i18n-context are exported from the 'gt-react/browser' entry point.
+ */
+/**
+ * Translate a message
+ * @param {string} message - The message to translate.
+ * @param {InlineTranslationOptions} [options] - The options for the translation.
+ * @returns {string} The translated message.
+ *
+ * This is a BROWSER ONLY function.
+ *
+ * @example
+ * t('Hello, world!'); // Translates 'Hello, world!'
+ *
+ * @example
+ * t('Hello, {name}!', { name: 'John' }); // Translates 'Hello, John!'
+ *
+ * @example
+ * t`Hello, ${name}` // Translate via tagged template literal
+ *
+ */
+declare const t: StringOrTemplateSyncResolutionFunction;
+//#endregion
+//#region src/i18n-context/functions/translation/GtInternalRuntimeTranslateString.d.ts
+type RuntimeStringTranslationOptions = Omit<RuntimeTranslationOptions, '$format'> & {
+  $format?: StringFormat;
+};
+/**
+ * Internal runtime translate string function for dev only
+ */
+declare const GtInternalRuntimeTranslateString: (content: string, options?: RuntimeStringTranslationOptions) => Promise<string>;
+//#endregion
+//#region src/i18n-context/functions/translation/GtInternalRuntimeTranslateJsx.d.ts
+type RuntimeJsxTranslationOptions = JsxTranslationOptions$1 & {
+  $locale?: string;
+};
+/**
+ * Internal runtime translate JSX function for dev only
+ */
+declare const GtInternalRuntimeTranslateJsx: (content: JsxChildren, options?: RuntimeJsxTranslationOptions) => Promise<JsxChildren>;
+//#endregion
+//#region src/i18n-context/functions/translation/GtInternalTranslateJsx.d.ts
+type TranslateJsxProps = {
+  children: ReactNode;
+} & JsxTranslationOptions;
+/**
+ * Equivalent to the `<T>` component, but used for auto insertion
+ */
+declare function GtInternalTranslateJsx(props: TranslateJsxProps): ReactNode;
+declare namespace GtInternalTranslateJsx {
+  var _gtt: string;
+}
+/**
+ * User facing component for translation.
+ */
+declare function T(props: TranslateJsxProps): ReactNode;
+declare namespace T {
+  var _gtt: string;
+}
+/**
+ * Strips the sugar character $ from option keys (e.g. `$context` → `context`).
+ */
+type StripDollarPrefix<T> = { [K in keyof T as K extends `$${infer Rest}` ? Rest : K]: T[K] };
+/**
+ * Internal type for the JsxTranslationOptions.
+ * @internal
+ */
+type JsxTranslationOptions = StripDollarPrefix<JsxTranslationOptions$1> & JsxTranslationOptions$1; //# sourceMappingURL=GtInternalTranslateJsx.d.ts.map
+//#endregion
+//#region src/i18n-context/functions/variables/GtInternalVar.d.ts
+type VarProps<T extends ReactNode> = {
+  children: T;
+  name?: string;
+};
+/**
+ * Equivalent to the `<Var>` component, but used for auto insertion
+ */
+declare function GtInternalVar<T extends ReactNode>({
+  children
+}: VarProps<T>): T;
+declare namespace GtInternalVar {
+  var _gtt: string;
+}
+/**
+ * User facing version of the Var component
+ */
+declare function Var<T extends ReactNode>({
+  children
+}: VarProps<T>): T;
+declare namespace Var {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/variables/GtInternalNum.d.ts
+type NumProps = {
+  children: number | string | null | undefined;
+  options?: Intl.NumberFormatOptions;
+  locales?: string[];
+  name?: string;
+};
+/**
+ * Equivalent to the `<Num>` component, but used for auto insertion
+ */
+declare function GtInternalNum({
+  children,
+  options,
+  locales: localesProp
+}: NumProps): string | null;
+declare namespace GtInternalNum {
+  var _gtt: string;
+}
+/**
+ * User facing component for the `<Num>` variable
+ */
+declare function Num(props: NumProps): string | null;
+declare namespace Num {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/variables/GtInternalDateTime.d.ts
+type DateTimeProps = {
+  children: Date | null | undefined;
+  locales?: string[];
+  options?: Intl.DateTimeFormatOptions;
+  name?: string;
+};
+/**
+ * Equivalent to the `<DateTime>` component, but used for auto insertion
+ */
+declare function GtInternalDateTime({
+  children,
+  options,
+  locales: localesProp
+}: DateTimeProps): string | null;
+declare namespace GtInternalDateTime {
+  var _gtt: string;
+}
+/**
+ * User facing component for the `<DateTime>` variable
+ */
+declare function DateTime(props: DateTimeProps): string | null;
+declare namespace DateTime {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/variables/GtInternalCurrency.d.ts
+type CurrencyProps = {
+  children: number | string | null | undefined;
+  currency?: string;
+  options?: Intl.NumberFormatOptions;
+  locales?: string[];
+  name?: string;
+};
+/**
+ * Equivalent to the `<Currency>` component, but used for auto insertion
+ */
+declare function GtInternalCurrency({
+  children,
+  currency,
+  options,
+  locales: localesProp
+}: CurrencyProps): string | null;
+declare namespace GtInternalCurrency {
+  var _gtt: string;
+}
+/**
+ * User facing component for the `<Currency>` variable
+ */
+declare function Currency(props: CurrencyProps): string | null;
+declare namespace Currency {
+  var _gtt: string;
+}
+//#endregion
+//#region src/i18n-context/functions/variables/GtInternalRelativeTime.d.ts
+type RelativeTimeProps = {
+  date?: Date | null | undefined;
+  children?: Date | null | undefined; /** Used by the GT CLI for additional context during extraction. */
+  name?: string;
+  value?: number;
+  unit?: Intl.RelativeTimeFormatUnit; /** Base date for computing relative time. Defaults to `new Date()` at render time. Required for hydration safety. */
+  baseDate?: Date;
+  locales?: string[];
+  options?: Intl.RelativeTimeFormatOptions;
+};
+/**
+ * Equivalent to the `<RelativeTime>` component, but used for auto insertion
+ */
+declare function GtInternalRelativeTime({
+  date,
+  children,
+  value,
+  unit,
+  baseDate,
+  locales: localesProp,
+  options
+}: RelativeTimeProps): string | null;
+declare namespace GtInternalRelativeTime {
+  var _gtt: string;
+}
+/**
+ * User facing component for the `<RelativeTime>` variable
+ */
+declare function RelativeTime(props: RelativeTimeProps): string | null;
+declare namespace RelativeTime {
+  var _gtt: string;
+}
+//#endregion
+//#region ../i18n/dist/index-UDlCzB02.d.cts
+//#region src/helpers/locale.d.ts
+/**
+ * Get the current locale
+ * @returns The current locale
+ *
+ * @example
+ * const locale = getLocale();
+ * console.log(locale); // 'en-US'
+ */
+declare function getLocale(): string;
+/**
+ * Get the configured locales
+ * @returns The configured locales
+ *
+ * @example
+ * const locales = getLocales();
+ * console.log(locales); // ['en-US', 'es-ES']
+ */
+declare function getLocales(): string[];
+/**
+ * Get the default locale
+ * @returns The default locale
+ *
+ * @example
+ * const defaultLocale = getDefaultLocale();
+ * console.log(defaultLocale); // 'en-US'
+ */
+declare function getDefaultLocale(): string;
+/**
+ * Get the locale properties
+ * @param {string} [locale] - The locale to get the properties for. When not provided, uses the current locale.
+ * @returns The locale properties
+ *
+ * @example
+ * const localeProperties = getLocaleProperties();
+ *
+ * @example
+ * const localeProperties = getLocaleProperties('en-US');
+ */
+//#endregion
+//#region src/helpers/versionId.d.ts
+/**
+ * Get the version ID for the current source
+ * @returns The version ID, if set
+ *
+ * @example
+ * const versionId = getVersionId();
+ * console.log(versionId); // 'abc123'
+ */
+declare function getVersionId(): string | undefined; //#endregion
+//#endregion
+//#region src/i18n-context/functions/locale-operations.d.ts
+/**
+ * Sets the user's current locale.
+ *
+ * @note This function causes a page reload
+ *
+ * @example
+ * setLocale('es-ES');
+ */
+declare function setLocale(locale: string): void;
+//#endregion
+//#region src/i18n-context/functions/html-tag-operations.d.ts
+/**
+ * Update the html tag lang property
+ * @param {string} locale - The locale to update the html tag lang property to
+ * @returns {void}
+ *
+ * @example
+ * updateHtmlTagLang('en');
+ */
+declare function updateHtmlTagLang(locale: string): void;
+/**
+ * Update the html tag dir property
+ * @param {string} dir - The direction to update the html tag dir property to
+ * @returns {void}
+ *
+ * @example
+ * updateHtmlTagDir('ltr');
+ */
+declare function updateHtmlTagDir(dir: 'ltr' | 'rtl'): void;
+//#endregion
+//#region src/i18n-context/ui/LocaleSelector.d.ts
+/**
+ * A dropdown component that allows users to select a locale.
+ * @param {string[]} [locales] - An optional list of locales to use for the dropdown. If not provided, the list of locales from the `<GTProvider>` context is used.
+ * @param {object} [customNames] - (deprecated) An optional object to map locales to custom names. Use `customMapping` instead.
+ * @param {CustomMapping} [customMapping] - An optional object to map locales to custom display names, emojis, or other properties.
+ * @returns {React.ReactElement | null} The rendered locale dropdown component or null to prevent rendering.
+ */
+declare function LocaleSelector({
+  locales,
+  ...props
+}: {
+  locales?: string[];
+  customNames?: {
+    [key: string]: string;
+  };
+  customMapping?: CustomMapping;
+  [key: string]: unknown;
+}): JSX.Element | null;
+//#endregion
+export { Branch, Currency, DateTime, Derive, GtInternalBranch, GtInternalCurrency, GtInternalDateTime, GtInternalDerive, GtInternalNum, GtInternalPlural, GtInternalRelativeTime, GtInternalRuntimeTranslateJsx, GtInternalRuntimeTranslateString, GtInternalTranslateJsx, GtInternalVar, LocaleSelector, Num, Plural, RelativeTime, type SyncResolutionFunction, type SyncResolutionFunctionWithFallback, T, Var, bootstrap, getDefaultLocale, getLocale, getLocales, getVersionId, initializeGT, setLocale, t, updateHtmlTagDir, updateHtmlTagLang };
+//# sourceMappingURL=browser.d.mts.map