@ui5/webcomponents-base 0.0.0-e463d2345 → 0.0.0-e55c2cec6

package/src/asset-registries/Icons.ts

@@ -0,0 +1,162 @@
+import getSharedResource from "../getSharedResource.js";
+import IconCollectionsAlias from "../assets-meta/IconCollectionsAlias.js";
+import { getEffectiveDefaultIconCollection } from "../config/Icons.js";
+import { I18nText } from "../i18nBundle.js";
+import { TemplateFunction } from "../renderer/executeTemplate.js";
+
+type IconLoader = (collectionName: string) => Promise<CollectionData>;
+
+type CollectionData = {
+	collection: string,
+	packageName: string,
+	version?: string,
+	data: Record<string, {
+		path: string,
+		paths: Array<string>,
+		ltr: boolean,
+		acc: I18nText,
+	}>,
+};
+
+type IconData = {
+	collection?: string,
+	packageName: string,
+	pathData: string | Array<string>,
+	ltr: boolean,
+	accData: I18nText,
+	customTemplate?: TemplateFunction,
+	viewBox?: string,
+};
+
+const loaders = new Map<string, IconLoader>();
+const registry = getSharedResource<Map<string, IconData>>("SVGIcons.registry", new Map());
+const iconCollectionPromises = getSharedResource<Map<string, Promise<CollectionData>>>("SVGIcons.promises", new Map());
+
+const ICON_NOT_FOUND = "ICON_NOT_FOUND";
+
+const registerIconLoader = (collectionName: string, loader: IconLoader) => {
+	loaders.set(collectionName, loader);
+};
+
+const _loadIconCollectionOnce = async (collectionName: string) => {
+	if (!iconCollectionPromises.has(collectionName)) {
+		if (!loaders.has(collectionName)) {
+			throw new Error(`No loader registered for the ${collectionName} icons collection. Probably you forgot to import the "AllIcons.js" module for the respective package.`);
+		}
+
+		const loadIcons = loaders.get(collectionName)!;
+		iconCollectionPromises.set(collectionName, loadIcons(collectionName));
+	}
+
+	return iconCollectionPromises.get(collectionName);
+};
+
+const _fillRegistry = (bundleData: CollectionData) => {
+	Object.keys(bundleData.data).forEach(iconName => {
+		const iconData = bundleData.data[iconName];
+
+		registerIcon(iconName, {
+			pathData: iconData.path || iconData.paths,
+			ltr: iconData.ltr,
+			accData: iconData.acc,
+			collection: bundleData.collection,
+			packageName: bundleData.packageName,
+		});
+	});
+};
+
+// set
+const registerIcon = (name: string, iconData: IconData) => { // eslint-disable-line
+	if (!iconData.collection) {
+		iconData.collection = getEffectiveDefaultIconCollection();
+	}
+
+	const key = `${iconData.collection}/${name}`;
+	registry.set(key, {
+		pathData: iconData.pathData,
+		ltr: iconData.ltr,
+		accData: iconData.accData,
+		packageName: iconData.packageName,
+		customTemplate: iconData.customTemplate,
+		viewBox: iconData.viewBox,
+	});
+};
+
+const _parseName = (name: string) => {
+	// silently support ui5-compatible URIs
+	if (name.startsWith("sap-icon://")) {
+		name = name.replace("sap-icon://", "");
+	}
+
+	let collection;
+	[name, collection] = name.split("/").reverse();
+	collection = collection || getEffectiveDefaultIconCollection();
+
+	// Normalize collection name.
+	// - resolve `SAP-icons-TNT` to `tnt`.
+	// - resolve `BusinessSuiteInAppSymbols` to `business-suite`.
+	// - resolve `horizon` to `SAP-icons-v5`,
+	// Note: aliases can be made as a feature, if more collections need it or more aliases are needed.
+	collection = _normalizeCollection(collection);
+	name = name.replace("icon-", "");
+
+	const registryKey = `${collection}/${name}`;
+	return { name, collection, registryKey };
+};
+
+const getIconDataSync = (name: string) => {
+	const { registryKey } = _parseName(name);
+	return registry.get(registryKey);
+};
+
+const getIconData = async (name: string) => {
+	const { collection, registryKey } = _parseName(name);
+
+	let iconData: string | CollectionData = ICON_NOT_FOUND;
+	try {
+		iconData = (await _loadIconCollectionOnce(collection))!;
+	} catch (error: unknown) {
+		const e = error as Error;
+		console.error(e.message); /* eslint-disable-line */
+	}
+
+	if (iconData === ICON_NOT_FOUND) {
+		return iconData;
+	}
+
+	if (!registry.has(registryKey)) {
+		// not filled by another await. many getters will await on the same loader, but fill only once
+		_fillRegistry(iconData as CollectionData);
+	}
+	return registry.get(registryKey);
+};
+
+// test page usage only
+const _getRegisteredNames = async () => {
+	// fetch one icon of each collection to trigger the bundle load
+	await getIconData("edit");
+	await getIconData("tnt/arrow");
+	await getIconData("business-suite/3d");
+	return Array.from(registry.keys());
+};
+
+const _normalizeCollection = (collectionName: string) => {
+	if (IconCollectionsAlias[collectionName as keyof typeof IconCollectionsAlias]) {
+		return IconCollectionsAlias[collectionName as keyof typeof IconCollectionsAlias];
+	}
+
+	return collectionName;
+};
+
+export {
+	registerIconLoader,
+	getIconData,
+	getIconDataSync,
+	registerIcon,
+	_getRegisteredNames,
+};
+
+export type {
+	IconData,
+	CollectionData,
+};

package/src/asset-registries/Illustrations.ts

@@ -0,0 +1,75 @@
+import getSharedResource from "../getSharedResource.js";
+import { I18nText } from "../i18nBundle.js";
+
+type IllustrationLoader = (illustrationName: string) => Promise<IllustrationData>;
+
+type IllustrationProperties = {
+	dialogSvg: string,
+	sceneSvg: string,
+	spotSvg: string,
+	title: I18nText,
+	subtitle: I18nText,
+};
+
+type IllustrationData = IllustrationProperties & {
+	set: string,
+};
+
+const loaders = new Map<string, IllustrationLoader>();
+const registry = getSharedResource<Map<string, IllustrationProperties>>("SVGIllustration.registry", new Map());
+const illustrationPromises = getSharedResource<Map<string, Promise<IllustrationData>>>("SVGIllustration.promises", new Map());
+
+const registerIllustration = (name: string, data: IllustrationData) => {
+	registry.set(`${data.set}/${name}`, {
+		dialogSvg: data.dialogSvg,
+		sceneSvg: data.sceneSvg,
+		spotSvg: data.spotSvg,
+		title: data.title,
+		subtitle: data.subtitle,
+	});
+};
+
+const registerIllustrationLoader = (illustrationName: string, loader: IllustrationLoader) => {
+	loaders.set(illustrationName, loader);
+};
+
+const _loadIllustrationOnce = async (illustrationName: string) => {
+	if (!illustrationPromises.has(illustrationName)) {
+		if (!loaders.has(illustrationName)) {
+			const illustrationPath = illustrationName.startsWith("Tnt") ? `tnt/${illustrationName.replace(/^Tnt/, "")}` : illustrationName;
+			throw new Error(`No loader registered for the ${illustrationName} illustration. Probably you forgot to import the "@ui5/webcomponents-fiori/dist/illustrations/${illustrationPath}.js" module. Or you can import the "@ui5/webcomponents-fiori/dist/illustrations/AllIllustrations.js" module that will make all illustrations available, but fetch only the ones used.`);
+		}
+
+		const loadIllustrations = loaders.get(illustrationName)!;
+		illustrationPromises.set(illustrationName, loadIllustrations(illustrationName));
+	}
+	return illustrationPromises.get(illustrationName);
+};
+
+const getIllustrationDataSync = (illustrationName: string) => {
+	let set = "fiori";
+
+	if (illustrationName.startsWith("Tnt")) {
+		set = "tnt";
+		illustrationName = illustrationName.replace(/^Tnt/, "");
+	}
+	return registry.get(`${set}/${illustrationName}`);
+};
+
+const getIllustrationData = async (illustrationName: string) => {
+	let set = "fiori";
+
+	await _loadIllustrationOnce(illustrationName);
+	if (illustrationName.startsWith("Tnt")) {
+		set = "tnt";
+		illustrationName = illustrationName.replace(/^Tnt/, "");
+	}
+	return registry.get(`${set}/${illustrationName}`);
+};
+
+export {
+	getIllustrationDataSync,
+	registerIllustration,
+	registerIllustrationLoader,
+	getIllustrationData,
+};

package/src/asset-registries/LocaleData.ts

@@ -0,0 +1,172 @@
+import { attachLanguageChange } from "../locale/languageChange.js";
+import getLocale from "../locale/getLocale.js";
+import { DEFAULT_LOCALE, SUPPORTED_LOCALES } from "../generated/AssetParameters.js";
+import { getFeature } from "../FeaturesRegistry.js";
+import type OpenUI5Support from "../features/OpenUI5Support";
+
+type LocaleDataLoader = (locale: string) => Promise<CLDRData>;
+type CLDRData = Record<string, object | boolean | string>;
+
+const localeDataMap = new Map<string, CLDRData>();
+const loaders = new Map<string, LocaleDataLoader>();
+const cldrPromises = new Map<string, Promise<CLDRData>>();
+const reportedErrors = new Set<string>();
+let warningShown = false;
+
+const M_ISO639_OLD_TO_NEW = {
+	"iw": "he",
+	"ji": "yi",
+	"in": "id",
+};
+
+const _showAssetsWarningOnce = (localeId: string) => {
+	if (warningShown) {
+		return;
+	}
+
+	console.warn(`[LocaleData] Supported locale "${localeId}" not configured, import the "Assets.js" module from the webcomponents package you are using.`); /* eslint-disable-line */
+
+	warningShown = true;
+};
+
+const calcLocale = (language: string, region: string, script: string) => {
+	// normalize language and handle special cases
+	language = (language && M_ISO639_OLD_TO_NEW[language as keyof typeof M_ISO639_OLD_TO_NEW]) || language;
+	// Special case 1: in an SAP context, the inclusive language code "no" always means Norwegian Bokmal ("nb")
+	if (language === "no") {
+		language = "nb";
+	}
+	// Special case 2: for Chinese, derive a default region from the script (this behavior is inherited from Java)
+	if (language === "zh" && !region) {
+		if (script === "Hans") {
+			region = "CN";
+		} else if (script === "Hant") {
+			region = "TW";
+		}
+	}
+
+	// Special case 3: for Serbian, there are cyrillic and latin scripts, "sh" and "sr-latn" map to "latin", "sr" maps to cyrillic.
+	if (language === "sh" || (language === "sr" && script === "Latn")) {
+		language = "sr";
+		region = "Latn";
+	}
+
+	// try language + region
+	let localeId = `${language}_${region}`;
+	if (SUPPORTED_LOCALES.includes(localeId)) {
+		if (loaders.has(localeId)) {
+			// supported and has loader
+			return localeId;
+		}
+
+		// supported, no loader - fallback to default and warn
+		_showAssetsWarningOnce(localeId);
+		return DEFAULT_LOCALE;
+	}
+
+	// not supported, try language only
+	localeId = language;
+	if (SUPPORTED_LOCALES.includes(localeId)) {
+		if (loaders.has(localeId)) {
+			// supported and has loader
+			return localeId;
+		}
+
+		// supported, no loader - fallback to default and warn
+		_showAssetsWarningOnce(localeId);
+		return DEFAULT_LOCALE;
+	}
+
+	// not supported - fallback to default locale
+	return DEFAULT_LOCALE;
+};
+
+// internal set data
+const setLocaleData = (localeId: string, content: CLDRData) => {
+	localeDataMap.set(localeId, content);
+};
+
+// external getSync
+const getLocaleData = (localeId: string) => {
+	// if there is no loader, the default fallback was fetched and a warning was given - use default locale instead
+	if (!loaders.has(localeId)) {
+		localeId = DEFAULT_LOCALE;
+	}
+
+	const content = localeDataMap.get(localeId);
+	if (!content) {
+		throw new Error(`CLDR data for locale ${localeId} is not loaded!`);
+	}
+
+	return content;
+};
+
+// load bundle over the network once
+const _loadCldrOnce = (localeId: string) => {
+	if (!cldrPromises.get(localeId)) {
+		const loadCldr = loaders.get(localeId);
+
+		if (!loadCldr) {
+			throw new Error(`CLDR data for locale ${localeId} is not loaded!`);
+		}
+
+		cldrPromises.set(localeId, loadCldr(localeId));
+	}
+
+	return cldrPromises.get(localeId);
+};
+
+// external getAsync
+const fetchCldr = async (language: string, region: string, script: string) => {
+	const localeId = calcLocale(language, region, script);
+
+	// reuse OpenUI5 CLDR if present
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+	if (openUI5Support) {
+		const cldrContent = openUI5Support.getLocaleDataObject();
+		if (cldrContent) {
+			// only if openui5 actually returned valid content
+			setLocaleData(localeId, cldrContent);
+			return;
+		}
+	}
+
+	// fetch it
+	try {
+		const cldrContent = await _loadCldrOnce(localeId);
+		setLocaleData(localeId, cldrContent as CLDRData);
+	} catch (error: unknown) {
+		const e = error as Error;
+		if (!reportedErrors.has(e.message)) {
+			reportedErrors.add(e.message);
+			console.error(e.message); /* eslint-disable-line */
+		}
+	}
+};
+
+const registerLocaleDataLoader = (localeId: string, loader: LocaleDataLoader) => {
+	loaders.set(localeId, loader);
+};
+
+// register default loader for "en" from ui5 CDN (dev workflow without assets)
+registerLocaleDataLoader("en", async () => {
+	const cldrContent = await fetch(`https://sdk.openui5.org/1.103.0/resources/sap/ui/core/cldr/en.json`);
+	return cldrContent.json() as Promise<CLDRData>;
+});
+
+// When the language changes dynamically (the user calls setLanguage),
+// re-fetch the required CDRD data.
+attachLanguageChange(() => {
+	const locale = getLocale();
+	return fetchCldr(locale.getLanguage(), locale.getRegion(), locale.getScript());
+});
+
+export {
+	registerLocaleDataLoader,
+	fetchCldr,
+	getLocaleData,
+};
+
+export type {
+	CLDRData,
+};

package/src/asset-registries/Themes.ts

@@ -0,0 +1,67 @@
+import { DEFAULT_THEME } from "../generated/AssetParameters.js";
+import { StyleData, StyleDataCSP } from "../types.js";
+
+type ThemeData = {_: StyleDataCSP } | StyleDataCSP | string;
+type ThemeLoader = (themeName: string) => Promise<ThemeData>;
+
+const themeStyles = new Map<string, StyleData>();
+const loaders = new Map<string, ThemeLoader>();
+const registeredPackages = new Set<string>();
+const registeredThemes = new Set<string>();
+
+const registerThemePropertiesLoader = (packageName: string, themeName: string, loader: ThemeLoader) => {
+	loaders.set(`${packageName}/${themeName}`, loader);
+	registeredPackages.add(packageName);
+	registeredThemes.add(themeName);
+};
+
+const getThemeProperties = async (packageName: string, themeName: string) => {
+	const style = themeStyles.get(`${packageName}_${themeName}`);
+	if (style !== undefined) { // it's valid for style to be an empty string
+		return style;
+	}
+
+	if (!registeredThemes.has(themeName)) {
+		const regThemesStr = [...registeredThemes.values()].join(", ");
+		console.warn(`You have requested a non-registered theme ${themeName} - falling back to ${DEFAULT_THEME}. Registered themes are: ${regThemesStr}`); /* eslint-disable-line */
+		return _getThemeProperties(packageName, DEFAULT_THEME);
+	}
+
+	return _getThemeProperties(packageName, themeName);
+};
+
+const _getThemeProperties = async (packageName: string, themeName: string) => {
+	const loader = loaders.get(`${packageName}/${themeName}`);
+	if (!loader) {
+		// no themes for package
+		console.error(`Theme [${themeName}] not registered for package [${packageName}]`); /* eslint-disable-line */
+		return;
+	}
+	let data;
+	try {
+		data = await loader(themeName);
+	} catch (error: unknown) {
+		const e = error as Error;
+		console.error(packageName, e.message); /* eslint-disable-line */
+		return;
+	}
+	const themeProps = (data as {_: StyleDataCSP})._ || data; // Refactor: remove _ everywhere
+
+	themeStyles.set(`${packageName}_${themeName}`, themeProps);
+	return themeProps;
+};
+
+const getRegisteredPackages = () => {
+	return registeredPackages;
+};
+
+const isThemeRegistered = (theme: string) => {
+	return registeredThemes.has(theme);
+};
+
+export {
+	registerThemePropertiesLoader,
+	getThemeProperties,
+	getRegisteredPackages,
+	isThemeRegistered,
+};

package/src/asset-registries/i18n.ts

@@ -0,0 +1,118 @@
+import getLocale from "../locale/getLocale.js";
+import { attachLanguageChange } from "../locale/languageChange.js";
+import normalizeLocale from "../locale/normalizeLocale.js";
+import nextFallbackLocale from "../locale/nextFallbackLocale.js";
+import { DEFAULT_LANGUAGE } from "../generated/AssetParameters.js";
+import { getFetchDefaultLanguage } from "../config/Language.js";
+
+type I18nLoader = (localeId: string) => Promise<I18nData>;
+type I18nData = Record<string, string>;
+
+// contains package names for which the warning has been shown
+const warningShown = new Set();
+const reportedErrors = new Set();
+
+const bundleData = new Map<string, I18nData | null>();
+const bundlePromises = new Map<string, Promise<I18nData>>();
+const loaders = new Map<string, I18nLoader>();
+
+/**
+ * Registers i18n loader function for given package and locale.
+ *
+ * @public
+ * @param {string} packageName for which package this loader can fetch data
+ * @param {string} localeId locale that this loader can handle
+ * @param {function} loader async function that will be passed a localeId and should return a JSON object
+ */
+const registerI18nLoader = (packageName: string, localeId: string, loader: I18nLoader) => {
+	// register loader by key
+	const bundleKey = `${packageName}/${localeId}`;
+	loaders.set(bundleKey, loader);
+};
+
+const _setI18nBundleData = (packageName: string, data: I18nData | null) => {
+	bundleData.set(packageName, data);
+};
+
+const getI18nBundleData = (packageName: string) => {
+	return bundleData.get(packageName);
+};
+
+const _hasLoader = (packageName: string, localeId: string) => {
+	const bundleKey = `${packageName}/${localeId}`;
+	return loaders.has(bundleKey);
+};
+
+// load bundle over the network once
+const _loadMessageBundleOnce = (packageName: string, localeId: string) => {
+	const bundleKey = `${packageName}/${localeId}`;
+	const loadMessageBundle = loaders.get(bundleKey);
+
+	if (loadMessageBundle && !bundlePromises.get(bundleKey)) {
+		bundlePromises.set(bundleKey, loadMessageBundle(localeId));
+	}
+
+	return bundlePromises.get(bundleKey)!; // Investigate if i18n loader exists and this won't return undefined.
+};
+
+const _showAssetsWarningOnce = (packageName: string) => {
+	if (!warningShown.has(packageName)) {
+		console.warn(`[${packageName}]: Message bundle assets are not configured. Falling back to English texts.`, /* eslint-disable-line */
+		` Add \`import "${packageName}/dist/Assets.js"\` in your bundle and make sure your build tool supports dynamic imports and JSON imports. See section "Assets" in the documentation for more information.`); /* eslint-disable-line */
+		warningShown.add(packageName);
+	}
+};
+
+/**
+ * This method preforms the asynchronous task of fetching the actual text resources. It will fetch
+ * each text resource over the network once (even for multiple calls to the same method).
+ * It should be fully finished before the i18nBundle class is created in the webcomponents.
+ * This method uses the bundle URLs that are populated by the <code>registerI18nBundle</code> method.
+ * To simplify the usage, the synchronization of both methods happens internally for the same <code>bundleId</code>
+ * @param {packageName} packageName the NPM package name
+ * @public
+ */
+const fetchI18nBundle = async (packageName: string) => {
+	const language = getLocale().getLanguage();
+	const region = getLocale().getRegion();
+	let localeId = normalizeLocale(language + (region ? `-${region}` : ``));
+
+	while (localeId !== DEFAULT_LANGUAGE && !_hasLoader(packageName, localeId)) {
+		localeId = nextFallbackLocale(localeId);
+	}
+
+	// use default language unless configured to always fetch it from the network
+	const fetchDefaultLanguage = getFetchDefaultLanguage();
+	if (localeId === DEFAULT_LANGUAGE && !fetchDefaultLanguage) {
+		_setI18nBundleData(packageName, null); // reset for the default language (if data was set for a previous language)
+		return;
+	}
+
+	if (!_hasLoader(packageName, localeId)) {
+		_showAssetsWarningOnce(packageName);
+		return;
+	}
+
+	try {
+		const data = await _loadMessageBundleOnce(packageName, localeId);
+		_setI18nBundleData(packageName, data);
+	} catch (error: unknown) {
+		const e = error as Error;
+		if (!reportedErrors.has(e.message)) {
+			reportedErrors.add(e.message);
+			console.error(e.message); /* eslint-disable-line */
+		}
+	}
+};
+
+// When the language changes dynamically (the user calls setLanguage), re-fetch all previously fetched bundles
+attachLanguageChange((lang: string /* eslint-disable-line */) => {
+	const allPackages = [...bundleData.keys()];
+	return Promise.all(allPackages.map(fetchI18nBundle));
+});
+
+export {
+	registerI18nLoader,
+	fetchI18nBundle,
+	getI18nBundleData,
+};

package/src/assets-meta/IconCollectionsAlias.ts

@@ -0,0 +1,18 @@
+/**
+ * Supported icon collection names and aliases.
+ *
+ * Users might specify a collection, using both the key and the value in the following key-value pairs,
+ * e.g the following pairs are completely exchangeable:
+ * "SAP-icons-TNT/actor" and "tnt/actor", "BusinessSuiteInAppSymbols/3d" and "business-suite/3d",
+ * "SAP-icons-v5/accept" and "horizon/accept".
+ *
+ * Note: technically, in the code we maintain the collections under the "value" name - "tnt", "business-suite",
+ * SAP-icons-v5" and "SAP-icons"(which does not have an alias).
+ */
+const IconCollectionsAlias = {
+	"SAP-icons-TNT": "tnt",
+	"BusinessSuiteInAppSymbols": "business-suite",
+	"horizon": "SAP-icons-v5",
+};
+
+export default IconCollectionsAlias;

package/src/config/AnimationMode.ts

@@ -0,0 +1,33 @@
+import { getAnimationMode as getConfiguredAnimationMode } from "../InitialConfiguration.js";
+import AnimationMode from "../types/AnimationMode.js";
+
+let curAnimationMode: AnimationMode;
+
+/**
+ * Returns the animation mode - "full", "basic", "minimal" or "none".
+ * @public
+ * @returns { AnimationMode }
+ */
+const getAnimationMode = (): AnimationMode => {
+	if (curAnimationMode === undefined) {
+		curAnimationMode = getConfiguredAnimationMode();
+	}
+
+	return curAnimationMode;
+};
+
+/**
+ * Sets the animation mode - "full", "basic", "minimal" or "none".
+ * @public
+ * @param { AnimationMode } animationMode
+ */
+const setAnimationMode = (animationMode: AnimationMode) => {
+	if (Object.values(AnimationMode).includes(animationMode)) {
+		curAnimationMode = animationMode;
+	}
+};
+
+export {
+	getAnimationMode,
+	setAnimationMode,
+};

package/src/config/CalendarType.ts

@@ -0,0 +1,23 @@
+import CalendarType from "../types/CalendarType.js";
+import { getCalendarType as getConfiguredCalendarType } from "../InitialConfiguration.js";
+
+let calendarType: CalendarType | undefined;
+
+/**
+ * Returns the configured or default calendar type.
+ * @public
+ * @returns { CalendarType } the effective calendar type
+ */
+const getCalendarType = (): CalendarType => {
+	if (calendarType === undefined) {
+		calendarType = getConfiguredCalendarType();
+	}
+
+	if (calendarType && calendarType in CalendarType) {
+		return calendarType;
+	}
+
+	return CalendarType.Gregorian;
+};
+
+export { getCalendarType }; // eslint-disable-line

package/src/config/FormatSettings.ts

@@ -0,0 +1,21 @@
+import { getFormatSettings } from "../InitialConfiguration.js";
+
+type FormatSettings = { firstDayOfWeek?: number };
+
+let formatSettings: FormatSettings;
+
+/**
+ * Returns the first day of the week from the configured format settings or based on the current locale.
+ * @public
+ * @returns {Number} 0 (Sunday) through 6 (Saturday)
+ */
+const getFirstDayOfWeek = (): number | undefined => {
+	if (formatSettings === undefined) {
+		formatSettings = getFormatSettings();
+	}
+
+	return formatSettings.firstDayOfWeek;
+};
+
+export { getFirstDayOfWeek }; // eslint-disable-line
+export type { FormatSettings };