@unbound-app/api 2.2.0 → 3.1.0

package/testing/fake-native.ts

@@ -1,7 +1,8 @@
 import type {
-	NativePluginBridge,
-	NativePluginCapability,
-	NativePluginPlatform,
+	NativeBridge,
+	NativeBridgeCapability,
+	NativeBridgeMethod,
+	NativeBridgePlatform,
 	PluginContext,
 } from '../src/native';
 import type { AddonManifest } from '../src/global';
@@ -14,17 +15,19 @@ import { createFakeObjc, type FakeObjc } from './fake-objc';
 /** What `startPlugin` takes to build the `PluginContext` its `start` receives; the rest is filled in as the client would. */
 export type StartContext = Partial<Omit<PluginContext, 'native'>> & {
 	/** The bridge members the plugin calls; the others are empty objects. */
-	native?: Partial<NativePluginBridge>;
+	native?: Partial<NativeBridge>;
 };
 
 /** The fake `native` namespace's state, which a test sets through the `native` recorder. */
 export type NativeState = {
 	/** The host platform `definePlatform` selects by and `Platform.OS` reports; `ios` until a test sets it. */
-	platform: NativePluginPlatform;
+	platform: NativeBridgePlatform;
 	/** The native modules `getNativeModule` finds, by name. */
 	modules: Map<string, unknown>;
 	/** The capabilities `native.has` reports. */
-	capabilities: NativePluginCapability[];
+	capabilities: NativeBridgeCapability[];
+	/** The bridge methods `native.supports` denies; every other method is supported. */
+	unsupportedMethods: NativeBridgeMethod[];
 };
 
 /** The fake `native`, its state, and the `PluginContext` builder. */
@@ -48,49 +51,53 @@ function emptyMember<T>(): T {
 	return Object.create(null);
 }
 
-const PLATFORMS: readonly NativePluginPlatform[] = ['ios', 'android'];
+// Keyed by every platform the SDK names, so a new one fails to typecheck until the fake serves it.
+const PLATFORMS: NativeBridgePlatform[] = Object.values({
+	ios: 'ios',
+	android: 'android',
+} as const satisfies { [P in NativeBridgePlatform]: P });
 
-class NativePluginUnavailableError extends Error {
+class NativeBridgeUnavailableError extends Error {
 	readonly code = 'NATIVE_PLUGIN_UNAVAILABLE';
 }
 
-class NativePluginCapabilityError extends Error {
+class NativeBridgeCapabilityError extends Error {
 	readonly code = 'NATIVE_PLUGIN_CAPABILITY_DENIED';
-	readonly capability: NativePluginCapability;
+	readonly capability: NativeBridgeCapability;
 
-	constructor(capability: NativePluginCapability) {
-		super(`Native plugin capability is not declared: ${capability}`);
+	constructor(capability: NativeBridgeCapability) {
+		super(`Native bridge capability is not declared: ${capability}`);
 		this.capability = capability;
 	}
 }
 
-class NativePluginUnsupportedPlatformError extends Error {
+class NativeBridgeUnsupportedPlatformError extends Error {
 	readonly code = 'NATIVE_PLUGIN_PLATFORM_EXCLUDED';
-	readonly platforms: readonly NativePluginPlatform[];
+	readonly platforms: readonly NativeBridgePlatform[];
 
-	constructor(platforms: readonly NativePluginPlatform[], platform: string) {
+	constructor(platforms: readonly NativeBridgePlatform[], platform: string) {
 		super(`This plugin supports ${platforms.join(', ')}; the host platform is ${platform}.`);
 		this.platforms = platforms;
 	}
 }
 
-class NativePluginVersionError extends Error {
+class NativeBridgeVersionError extends Error {
 	readonly code = 'NATIVE_PLUGIN_API_VERSION_UNSUPPORTED';
 	readonly installedApi: string;
 	readonly requiredApi: string;
 
 	constructor(requiredApi: string, installedApi: string) {
-		super(`Native plugin API ${requiredApi} is required, but ${installedApi} is installed.`);
+		super(`Native bridge API ${requiredApi} is required, but ${installedApi} is installed.`);
 		this.installedApi = installedApi;
 		this.requiredApi = requiredApi;
 	}
 }
 
-class NativePluginDisposedError extends Error {
+class NativeBridgeDisposedError extends Error {
 	readonly code = 'NATIVE_PLUGIN_SCOPE_DISPOSED';
 
 	constructor() {
-		super('The native plugin scope has been disposed.');
+		super('The native bridge scope has been disposed.');
 	}
 }
 
@@ -100,16 +107,21 @@ class NativePluginDisposedError extends Error {
  * @returns The namespace, its state, and the context builder.
  */
 export function createFakeNative(): FakeNative {
-	const state: NativeState = { platform: 'ios', modules: new Map(), capabilities: [] };
+	const state: NativeState = {
+		platform: 'ios',
+		modules: new Map(),
+		capabilities: [],
+		unsupportedMethods: [],
+	};
 	const log = createCallLog();
 	const objc = createFakeObjc(log);
 	const java = createFakeJava(log);
 
-	function select<Handler>(handlers: Partial<Record<NativePluginPlatform, Handler>>): Handler {
+	function select<Handler>(handlers: Partial<Record<NativeBridgePlatform, Handler>>): Handler {
 		const handler = handlers[state.platform];
 
 		if (handler === undefined) {
-			throw new NativePluginUnsupportedPlatformError(
+			throw new NativeBridgeUnsupportedPlatformError(
 				PLATFORMS.filter((name) => handlers[name] !== undefined),
 				state.platform,
 			);
@@ -121,7 +133,7 @@ export function createFakeNative(): FakeNative {
 	// A plugin selects as it imports platform.ts, before a test sets the platform, so a function handler
 	// is a forwarder to the current platform's handler. Any other value is read now.
 	function definePlatform<Handler>(
-		handlers: Partial<Record<NativePluginPlatform, Handler>>,
+		handlers: Partial<Record<NativeBridgePlatform, Handler>>,
 	): Handler {
 		const selected = select(handlers);
 
@@ -138,11 +150,11 @@ export function createFakeNative(): FakeNative {
 	}
 
 	const namespace: FakeModule = {
-		NativePluginUnavailableError,
-		NativePluginCapabilityError,
-		NativePluginUnsupportedPlatformError,
-		NativePluginVersionError,
-		NativePluginDisposedError,
+		NativeBridgeUnavailableError,
+		NativeBridgeCapabilityError,
+		NativeBridgeUnsupportedPlatformError,
+		NativeBridgeVersionError,
+		NativeBridgeDisposedError,
 		BundleInfo: {},
 		BundleManager: {},
 		DeviceInfo: {},
@@ -151,8 +163,9 @@ export function createFakeNative(): FakeNative {
 			names.map((name) => state.modules.get(name)).find(Boolean),
 		getNativeResources: () => undefined,
 		getRuntimeProperties: () => ({}),
-		has: (capability: NativePluginCapability) => state.capabilities.includes(capability),
+		has: (capability: NativeBridgeCapability) => state.capabilities.includes(capability),
 		reload: async () => {},
+		supports: (method: NativeBridgeMethod) => !state.unsupportedMethods.includes(method),
 	};
 
 	return {
@@ -168,11 +181,12 @@ export function createFakeNative(): FakeNative {
 			state.platform = 'ios';
 			state.modules.clear();
 			state.capabilities = [];
+			state.unsupportedMethods = [];
 		},
 		context(manifest, overrides = {}) {
 			const { native, ...rest } = overrides;
 			const capabilities = rest.capabilities ?? state.capabilities;
-			const bridge: NativePluginBridge = {
+			const bridge: NativeBridge = {
 				apiVersion: '1.0.0',
 				abiVersion: '1',
 				capabilities,

package/testing/fake-plugins.ts

@@ -38,7 +38,7 @@ export function createFakePlugins(own: AddonManifest): FakePlugins {
 	const states = new Map<string, State>();
 	const handles = new Map<string, AddonHandle>();
 	const errors = new Map<PropertyKey, Error>();
-	const entities = new Map<PropertyKey, AddonHandle>();
+	const addons = new Map<PropertyKey, AddonHandle>();
 	const startDurations = new Map<string, number>();
 
 	function stateOf(id: string): State | undefined {
@@ -110,7 +110,7 @@ export function createFakePlugins(own: AddonManifest): FakePlugins {
 			const handle = handleOf(id, id === own.id ? own : undefined);
 
 			handles.set(id, handle);
-			entities.set(id, handle);
+			addons.set(id, handle);
 		}
 
 		const error = stateOf(id)?.error;
@@ -125,7 +125,7 @@ export function createFakePlugins(own: AddonManifest): FakePlugins {
 	function remove(id: string) {
 		states.delete(id);
 		handles.delete(id);
-		entities.delete(id);
+		addons.delete(id);
 		errors.delete(id);
 	}
 
@@ -155,7 +155,7 @@ export function createFakePlugins(own: AddonManifest): FakePlugins {
 	reset();
 
 	const namespace: FakeModule = {
-		entities,
+		addons,
 		errors,
 		startDurations,
 		get: (id: string) => handles.get(id),

package/testing/fake-react-native-modules.ts

@@ -226,7 +226,6 @@ const identity = (value: number) => value;
 
 /**
  * @description Passes an easing curve through, since the fake draws no frames.
- * @param curve The curve.
  * @returns The same curve.
  */
 function keep(curve: Curve): Curve {

package/testing/fake-utils.ts

@@ -3,7 +3,9 @@ import { useRef } from 'react';
 import type { TreeNode, TreePredicate, TreeSearchOptions } from '../src/utils/index';
 import type { PredicateResult } from '../src/_types';
 
-// These mirror the client's `utils` line for line: the testing kit ships without the client's private packages.
+import walkTree from '../src/_conventions/walk-tree';
+
+// The tree walk is the client's own; the React finders below mirror the client's `utils/react`.
 
 /** What `findComponent` and `filterComponents` match by: a component name, or a predicate on each element. */
 type ComponentMatch = string | ((element: TreeNode) => PredicateResult);
@@ -28,64 +30,6 @@ const REACT_KEYS = [
 // Elements nest through their props, so only `props` and `children` lead to more elements.
 const ELEMENT_OPTIONS: TreeSearchOptions = { walkable: ['props', 'children'] };
 
-function walkTree(
-	root: TreeNode,
-	predicate: TreePredicate,
-	options: TreeSearchOptions,
-	all: boolean,
-): TreeNode[] {
-	const { walkable, ignore = [], maxDepth = 100 } = options;
-	const seen = new WeakSet<object>();
-	const found: TreeNode[] = [];
-
-	// Returns `true` once the search should stop.
-	function visit(node: TreeNode, depth: number): boolean {
-		if (node === null || node === undefined) {
-			return false;
-		}
-
-		const isObject = typeof node === 'object';
-
-		if (isObject) {
-			if (seen.has(node)) {
-				return false;
-			}
-
-			seen.add(node);
-		}
-
-		if (predicate(node)) {
-			found.push(node);
-
-			if (!all) {
-				return true;
-			}
-		}
-
-		if (!isObject || depth >= maxDepth) {
-			return false;
-		}
-
-		const keys = Array.isArray(node) ? node.keys() : (walkable ?? Object.keys(node));
-
-		for (const key of keys) {
-			if (typeof key === 'string' && ignore.includes(key)) {
-				continue;
-			}
-
-			if (visit(node[key], depth + 1)) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	visit(root, 0);
-
-	return found;
-}
-
 function reactOptions({ walkable = [], ...rest }: TreeSearchOptions): TreeSearchOptions {
 	return { ...rest, walkable: [...REACT_KEYS, ...walkable] };
 }

package/testing/fakes.ts

@@ -0,0 +1,8 @@
+export { createFakeSettings, defineSettings, setting, type FakeSettings } from './fake-settings';
+// The fakes the preset is built from, for testing shared code that runs inside plugins but is no plugin itself.
+export { installAddonGlobals, type InstalledAddonGlobals } from './install-addon-globals';
+export { createFakeJava, type FakeJava, type JavaPlain } from './fake-java';
+export { createMemoryStorage, type MemoryStorage } from './memory-storage';
+export { brand, settled, withMissingMembers } from './fake-native-bridge';
+export { createFakeNative, type FakeNative } from './fake-native';
+export { createRecordingPatcher } from './recording-patcher';

package/testing/icu-format.ts

@@ -4,7 +4,8 @@ import {
 	type IcuNode,
 	type IcuPluralNode,
 	type IcuSelectNode,
-} from './icu-parse';
+} from '../src/_conventions/icu-parse';
+import { SOURCE_LOCALE } from '../src/_conventions/addon-locales';
 
 /** A value `format` puts into a placeholder, as the client's `FormatVars` types it. */
 export type IcuValue = string | number | boolean | Date;
@@ -127,6 +128,10 @@ function formatNodes(nodes: IcuNode[], vars: IcuVars, locale: string, pound?: nu
  * @param locale The locale plural rules, numbers and dates follow, such as `de`.
  * @returns The formatted message.
  */
-export function formatIcu(message: string, vars: IcuVars = {}, locale: string = 'en-US'): string {
+export function formatIcu(
+	message: string,
+	vars: IcuVars = {},
+	locale: string = SOURCE_LOCALE,
+): string {
 	return formatNodes(parseIcu(message), vars, locale);
 }

package/testing/index.ts

@@ -1,3 +1,4 @@
+// What a plugin's tests import, beside the preset in their bunfig.toml: the lifecycle, `render` and the recorders.
 export {
 	toasts,
 	dialogs,
@@ -11,32 +12,18 @@ export {
 	logs,
 	setLocale,
 	extendApi,
+	type ToastRecorder,
+	type DialogRecorder,
+	type CommandRecorder,
+	type PatchRecorder,
+	type FluxRecorder,
+	type MetroRecorder,
+	type NativeRecorder,
+	type PluginRecorder,
+	type FsRecorder,
+	type LogRecorder,
 } from './recorders';
-export { act, createTestRenderer, type TestRenderer } from './test-renderer';
 export { startPlugin, stopPlugin, pluginHolds } from './plugin-lifecycle';
 export { render, type RenderOptions, type RenderResult } from './render';
-export * from './install-addon-globals';
-export * from './fake-native-bridge';
-export * from './fake-react-native';
-export * from './listener-registry';
-export * from './recording-patcher';
-export * from './fake-components';
-export * from './memory-storage';
-export * from './fake-feedback';
-export * from './fake-settings';
-export * from './fake-locales';
-export * from './fake-plugins';
-export * from './plugin-types';
-export * from './fake-native';
-export * from './fake-timers';
-export * from './react-value';
-export * from './fake-metro';
-export * from './fake-react';
-export * from './fake-utils';
-export * from './icu-format';
-export * from './fake-java';
-export * from './fake-objc';
-export * from './icu-parse';
-export * from './test-node';
-export * from './fake-api';
-export * from './fake-fs';
+export { fakeAssetId, type StoreSeeds } from './fake-api';
+export type { PluginTypes } from './plugin-types';

package/testing/install-addon-globals.ts

@@ -12,7 +12,7 @@ import type {
 	OptionValue,
 	Reply,
 } from '../src/commands';
-import type { AddonHandle, AddonLogger, AddonManifest } from '../src/global';
+import type { AddonHandle, AddonLogger, AddonManifest, AddonScope } from '../src/global';
 
 import { createRecordingPatcher, type RecordingPatcher } from './recording-patcher';
 import { createFakeMetro, type FakeMetro, type FakeModule } from './fake-metro';
@@ -82,6 +82,16 @@ export type InstalledAddonGlobals = {
 	uninstall: () => void;
 };
 
+// The fake each Addon scope global is; keying the installed globals by `AddonScope` fails typecheck on a new one.
+type ScopeFake =
+	| FakeReact
+	| FakeUnbound
+	| AddonHandle
+	| RecordingPatcher
+	| AddonLogger
+	| FakeCommands
+	| FakeTimers[keyof FakeTimers];
+
 const LOG_LEVELS: LogLevel[] = ['log', 'info', 'success', 'warn', 'error', 'debug'];
 
 function createLogger(logs: LogEntry[]): AddonLogger {
@@ -238,7 +248,7 @@ export function installAddonGlobals(options: InstallOptions = {}): InstalledAddo
 		setInterval: timers.setInterval,
 		clearTimeout: timers.clearTimeout,
 		clearInterval: timers.clearInterval,
-	};
+	} satisfies Record<keyof AddonScope, ScopeFake>;
 	const previous = new Map<string, PropertyDescriptor | undefined>();
 
 	for (const [name, value] of Object.entries(globals)) {

package/testing/plugin-files.ts

@@ -5,8 +5,14 @@ import type { AddonAuthor, AddonManifest } from '../src/global';
 import type { LocaleTable } from './fake-locales';
 import type { AnyObject } from '../src/patcher';
 
+import { ASSETS_DIRECTORY, ASSET_SCALES } from '../src/_conventions/addon-assets';
+import { LOCALES_DIRECTORY } from '../src/_conventions/addon-locales';
+
 const ENTRY_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js'];
 
+// The `@2x` and `@3x` an image's file name ends in at each scale above 1.
+const SCALE_SUFFIXES = ASSET_SCALES.filter((scale) => scale !== '1').map((scale) => `@${scale}x`);
+
 function isRecord(value: unknown): value is AnyObject {
 	return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -97,7 +103,7 @@ export function readManifest(root: string): Partial<AddonManifest> {
  * @returns Each table by locale code; empty when the plugin has no `i18n/`. Throws naming an invalid file.
  */
 export function readLocaleTables(root: string): Map<string, LocaleTable> {
-	const directory = join(root, 'i18n');
+	const directory = join(root, LOCALES_DIRECTORY);
 	const tables = new Map<string, LocaleTable>();
 
 	if (!existsSync(directory)) {
@@ -147,9 +153,11 @@ export function findEntry(root: string): string | undefined {
  * @returns The asset name, such as `icons/star`.
  */
 export function assetNameOf(root: string, path: string): string {
-	const assets = join(root, 'assets');
+	const assets = join(root, ASSETS_DIRECTORY);
 	const base = path.startsWith(assets + sep) ? assets : root;
 	const name = relative(base, path).slice(0, -extname(path).length).split(sep).join('/');
 
-	return name.endsWith('@2x') || name.endsWith('@3x') ? name.slice(0, -'@2x'.length) : name;
+	const suffix = SCALE_SUFFIXES.find((each) => name.endsWith(each));
+
+	return suffix ? name.slice(0, -suffix.length) : name;
 }

package/testing/preset.ts

@@ -18,10 +18,12 @@ import { createFakeSettings, defineSettings, setting, type SettingsSchema } from
 import { createListenerRegistry, type ListenerRegistry } from './listener-registry';
 import { createFakeReactNative, type HostPropsByName } from './fake-react-native';
 import { installAddonGlobals, type FakeUnbound } from './install-addon-globals';
-import { createFakeLocales, SOURCE_LOCALE } from './fake-locales';
+import { SOURCE_LOCALE } from '../src/_conventions/addon-locales';
+import { ASSET_TYPES } from '../src/_conventions/addon-assets';
 import { createFakeAssets, createFakeFlux } from './fake-api';
 import { createJsxRuntimes } from './unfrozen-elements';
 import { resetSession, startSession } from './session';
+import { createFakeLocales } from './fake-locales';
 import { createFakePlugins } from './fake-plugins';
 import { forgetPlugin } from './plugin-lifecycle';
 import { createFakeUi } from './fake-components';
@@ -29,16 +31,15 @@ import { createFakeNative } from './fake-native';
 import { createFakeUtils } from './fake-utils';
 import { unmountAll } from './test-renderer';
 import { createFakeFs } from './fake-fs';
+import sdk from '../package.json';
 
 type SvgProps = Omit<HostPropsByName['SvgXml'], 'xml' | 'asset'>;
 
-// The namespaces that serve nested modules, as `unbound.metro.components` is `@unbound-app/api/metro/components`.
-const NESTED = new Map([
-	['metro', ['api', 'common', 'components', 'filters', 'stores']],
-	['utils', ['react']],
-]);
+// The nested modules the SDK publishes, such as `metro/components` for `unbound.metro.components`.
+const NESTED = new Set(Object.keys(sdk.exports).map((subpath) => subpath.slice(2)));
 
-const IMAGE = /\.(png|jpe?g|webp|gif)$/i;
+// The build also takes `.jpeg` as a jpg.
+const IMAGE = new RegExp(`\\.(${[...ASSET_TYPES, 'jpeg'].join('|')})$`, 'i');
 const SVG = /\.svg$/i;
 const SVG_ASSET = /\.svg\?asset$/i;
 const SVG_ASSET_NAMESPACE = 'unbound-svg-asset';
@@ -175,7 +176,7 @@ for (const [name, namespace] of Object.entries(scope.unbound)) {
 
 	// A namespace that nests others serves each one at its own path, such as `@unbound-app/api/metro/components`.
 	for (const [nested, members] of Object.entries(namespace)) {
-		if (NESTED.get(name)?.includes(nested)) {
+		if (NESTED.has(`${name}/${nested}`)) {
 			mock.module(`@unbound-app/api/${name}/${nested}`, () => members);
 		}
 	}

package/testing/recorders.ts

@@ -1,4 +1,8 @@
-import type { NativePluginCapability, NativePluginPlatform } from '../src/native';
+import type {
+	NativeBridgeCapability,
+	NativeBridgeMethod,
+	NativeBridgePlatform,
+} from '../src/native';
 import type { CommandArgs, LogEntry } from './install-addon-globals';
 import type { OpenedDialog, ShownToast } from './fake-feedback';
 import type { CommandContext, Reply } from '../src/commands';
@@ -42,17 +46,23 @@ export type FluxRecorder = {
 };
 
 /** The fake metro's modules: `register` one for the plugin to find, such as `{ sendMessage }`. */
-export type MetroRecorder = { register: (module: FakeModule, path?: string) => void };
+export type MetroRecorder = {
+	register: (module: FakeModule, path?: string) => void;
+	/** Marks a prop name, file path or export name as missing from this build: a lazy lookup by it returns `undefined`, and `onModuleLoaded` calls `onMissing`. */
+	markMissing: (term: string) => void;
+};
 
 /** The fake `native`: the platform `definePlatform` selects by, and the modules and capabilities it reports. */
 export type NativeRecorder = {
 	/** Switches the host platform, `ios` until set; `definePlatform` and `Platform.OS` follow it. */
-	setPlatform: (platform: NativePluginPlatform) => void;
+	setPlatform: (platform: NativeBridgePlatform) => void;
 	/** Gives `getNativeModule(name)` a module to return. */
 	// UNKNOWN: a native module has whatever shape the plugin reads.
 	registerModule: (name: string, module: unknown) => void;
 	/** Sets what `native.has` reports. */
-	setCapabilities: (capabilities: NativePluginCapability[]) => void;
+	setCapabilities: (capabilities: NativeBridgeCapability[]) => void;
+	/** Sets the bridge methods `native.supports` denies, as on an older loader; none until set. */
+	setUnsupportedMethods: (methods: NativeBridgeMethod[]) => void;
 	/** The Objective-C bridge a plugin gets on iOS: register classes and objects for its calls to reach. */
 	readonly objc: FakeObjc;
 	/** The Java bridge a plugin gets on Android: register classes and objects for its calls to reach. */
@@ -108,12 +118,15 @@ function createRecorders() {
 	};
 	const metro: MetroRecorder = {
 		register: (module, path) => getSession().scope.metro.register(module, path),
+		markMissing: (term) => getSession().scope.metro.markMissing(term),
 	};
 	const native: NativeRecorder = {
 		setPlatform: (platform) => void (getSession().native.state.platform = platform),
 		registerModule: (name, module) => void getSession().native.state.modules.set(name, module),
 		setCapabilities: (capabilities) =>
 			void (getSession().native.state.capabilities = capabilities),
+		setUnsupportedMethods: (methods) =>
+			void (getSession().native.state.unsupportedMethods = methods),
 		get objc() {
 			return getSession().native.objc;
 		},

package/testing/session.ts

@@ -8,6 +8,7 @@ import type { FakePlugins } from './fake-plugins';
 import type { FakeNative } from './fake-native';
 import type { FakeFs } from './fake-fs';
 
+import { SOURCE_LOCALE } from '../src/_conventions/addon-locales';
 import { unmountAll } from './test-renderer';
 
 /** The plugin under test and every fake the preset installed for it. */
@@ -31,7 +32,6 @@ let active: TestSession | undefined;
 
 /**
  * @description Makes a session the one the recorders, `render` and `startPlugin` read. The preset calls it once.
- * @param session The session.
  */
 export function startSession(session: TestSession): void {
 	active = session;
@@ -73,5 +73,5 @@ export function resetSession(): void {
 	session.flux.reset();
 	session.toasts.shown.length = 0;
 	session.dialogs.opened.length = 0;
-	session.locales?.setLocale('en-US');
+	session.locales?.setLocale(SOURCE_LOCALE);
 }