@ui5/webcomponents-base 0.0.0-a3eca7ade → 0.0.0-a7032d86e

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.js → LocaleData.ts}

@@ -2,39 +2,36 @@ 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";
 
-const localeDataMap = new Map();
-const loaders = new Map();
-const cldrPromises = new Map();
-const reportedErrors = new Set();
+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",
-	"sh": "sr",
 };
 
-const DEV_MODE = false;
-
-const _showAssetsWarningOnce = localeId => {
+const _showAssetsWarningOnce = (localeId: string) => {
 	if (warningShown) {
 		return;
 	}
 
-	if (!DEV_MODE) {
-		console.warn(`[LocaleData] Supported locale "${localeId}" not configured, import the "Assets.js" module from the webcomponents package you are using.`); /* eslint-disable-line */
-	} else {
-		console.warn(`[LocaleData] Note: in dev mode, CLDR assets might be disabled for performance reasons. Try running "ENABLE_CLDR=1 yarn start" to test CLDR assets.`); /* eslint-disable-line */
-	}
+	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, region, script) => {
+const calcLocale = (language: string, region: string, script: string) => {
 	// normalize language and handle special cases
-	language = (language && M_ISO639_OLD_TO_NEW[language]) || language;
+	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";
@@ -48,6 +45,12 @@ const calcLocale = (language, region, script) => {
 		}
 	}
 
+	// 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)) {
@@ -79,12 +82,12 @@ const calcLocale = (language, region, script) => {
 };
 
 // internal set data
-const setLocaleData = (localeId, content) => {
+const setLocaleData = (localeId: string, content: CLDRData) => {
 	localeDataMap.set(localeId, content);
 };
 
 // external getSync
-const getLocaleData = localeId => {
+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;
@@ -99,10 +102,14 @@ const getLocaleData = localeId => {
 };
 
 // load bundle over the network once
-const _loadCldrOnce = localeId => {
-	const loadCldr = loaders.get(localeId);
-
+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));
 	}
 
@@ -110,13 +117,13 @@ const _loadCldrOnce = localeId => {
 };
 
 // external getAsync
-const fetchCldr = async (language, region, script) => {
+const fetchCldr = async (language: string, region: string, script: string) => {
 	const localeId = calcLocale(language, region, script);
 
 	// reuse OpenUI5 CLDR if present
-	const OpenUI5Support = getFeature("OpenUI5Support");
-	if (OpenUI5Support) {
-		const cldrContent = OpenUI5Support.getLocaleDataObject();
+	const openUI5Support = getFeature<typeof OpenUI5Support>("OpenUI5Support");
+	if (openUI5Support) {
+		const cldrContent = openUI5Support.getLocaleDataObject();
 		if (cldrContent) {
 			// only if openui5 actually returned valid content
 			setLocaleData(localeId, cldrContent);
@@ -127,8 +134,9 @@ const fetchCldr = async (language, region, script) => {
 	// fetch it
 	try {
 		const cldrContent = await _loadCldrOnce(localeId);
-		setLocaleData(localeId, cldrContent);
-	} catch (e) {
+		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 */
@@ -136,13 +144,14 @@ const fetchCldr = async (language, region, script) => {
 	}
 };
 
-const registerLocaleDataLoader = (localeId, loader) => {
+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 runtimeLocaleId => {
-	return (await fetch(`https://ui5.sap.com/1.60.2/resources/sap/ui/core/cldr/en.json`)).json();
+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),
@@ -157,3 +166,7 @@ export {
 	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.js → i18n.ts}

@@ -5,60 +5,57 @@ 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();
-const bundlePromises = new Map();
-const loaders = new Map();
+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
- * @param {Array} localeIds Array of locale IDs that this loader can handle
  */
-const registerI18nLoader = (packageName, localeId, loader) => {
+const registerI18nLoader = (packageName: string, localeId: string, loader: I18nLoader) => {
 	// register loader by key
 	const bundleKey = `${packageName}/${localeId}`;
 	loaders.set(bundleKey, loader);
 };
 
-const _setI18nBundleData = (packageName, data) => {
+const _setI18nBundleData = (packageName: string, data: I18nData | null) => {
 	bundleData.set(packageName, data);
 };
 
-const getI18nBundleData = packageName => {
+const getI18nBundleData = (packageName: string) => {
 	return bundleData.get(packageName);
 };
 
-/**
- * @public
- * @deprecated
- */
-const registerI18nBundle = (_packageName, _bundle) => {
-	throw new Error("This method has been removed. Use `registerI18nLoader` instead.");
-};
-
-const _hasLoader = (packageName, localeId) => {
+const _hasLoader = (packageName: string, localeId: string) => {
 	const bundleKey = `${packageName}/${localeId}`;
 	return loaders.has(bundleKey);
 };
 
 // load bundle over the network once
-const _loadMessageBundleOnce = (packageName, localeId) => {
+const _loadMessageBundleOnce = (packageName: string, localeId: string) => {
 	const bundleKey = `${packageName}/${localeId}`;
 	const loadMessageBundle = loaders.get(bundleKey);
 
-	if (!bundlePromises.get(bundleKey)) {
+	if (loadMessageBundle && !bundlePromises.get(bundleKey)) {
 		bundlePromises.set(bundleKey, loadMessageBundle(localeId));
 	}
 
-	return bundlePromises.get(bundleKey);
+	return bundlePromises.get(bundleKey)!; // Investigate if i18n loader exists and this won't return undefined.
 };
 
-const _showAssetsWarningOnce = packageName => {
+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 */
@@ -75,7 +72,7 @@ const _showAssetsWarningOnce = packageName => {
  * @param {packageName} packageName the NPM package name
  * @public
  */
-const fetchI18nBundle = async packageName => {
+const fetchI18nBundle = async (packageName: string) => {
 	const language = getLocale().getLanguage();
 	const region = getLocale().getRegion();
 	let localeId = normalizeLocale(language + (region ? `-${region}` : ``));
@@ -99,7 +96,8 @@ const fetchI18nBundle = async packageName => {
 	try {
 		const data = await _loadMessageBundleOnce(packageName, localeId);
 		_setI18nBundleData(packageName, data);
-	} catch (e) {
+	} catch (error: unknown) {
+		const e = error as Error;
 		if (!reportedErrors.has(e.message)) {
 			reportedErrors.add(e.message);
 			console.error(e.message); /* eslint-disable-line */
@@ -108,7 +106,7 @@ const fetchI18nBundle = async packageName => {
 };
 
 // When the language changes dynamically (the user calls setLanguage), re-fetch all previously fetched bundles
-attachLanguageChange(() => {
+attachLanguageChange((lang: string /* eslint-disable-line */) => {
 	const allPackages = [...bundleData.keys()];
 	return Promise.all(allPackages.map(fetchI18nBundle));
 });
@@ -116,6 +114,5 @@ attachLanguageChange(() => {
 export {
 	registerI18nLoader,
 	fetchI18nBundle,
-	registerI18nBundle,
 	getI18nBundleData,
 };

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.js → CalendarType.ts}

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

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 };