@ui5/webcomponents-tools 1.0.0-rc.8 → 1.0.2

package/lib/create-icons/index.js

@@ -2,34 +2,53 @@ const fs = require("fs");
 const path = require("path");
 const mkdirp = require("mkdirp");
 
-const srcDir = `src/icon-collections/`;
-const destDir = `dist/icons/`;
+const collectionName = process.argv[2] || "SAP-icons";
+const collectionVersion = process.argv[3];
+const srcFile = collectionVersion ? path.normalize(`src/${collectionVersion}/${collectionName}.json`) : path.normalize(`src/${collectionName}.json`);
+const destDir = collectionVersion ? path.normalize(`dist/${collectionVersion}/`) : path.normalize("dist/");
 
 mkdirp.sync(destDir);
 
-const template = (name, pathData, ltr) => `import { registerIcon } from "@ui5/webcomponents-base/dist/SVGIconRegistry.js";
+const iconTemplate = (name, pathData, ltr, collection, packageName) => `import { registerIcon } from "@ui5/webcomponents-base/dist/asset-registries/Icons.js";
 
 const name = "${name}";
 const pathData = "${pathData}";
 const ltr = ${ltr};
+const collection = "${collection}";
+const packageName = "${packageName}";
 
-registerIcon(name, { pathData, ltr});
+registerIcon(name, { pathData, ltr, collection, packageName });
 
 export default { pathData };`;
 
-const accTemplate = (name, pathData, ltr, accData) => `import { registerIcon } from "@ui5/webcomponents-base/dist/SVGIconRegistry.js";
+
+const iconAccTemplate = (name, pathData, ltr, accData, collection, packageName) => `import { registerIcon } from "@ui5/webcomponents-base/dist/asset-registries/Icons.js";
 import { ${accData.key} } from "../generated/i18n/i18n-defaults.js";
 
 const name = "${name}";
 const pathData = "${pathData}";
 const ltr = ${ltr};
 const accData = ${accData.key};
+const collection = "${collection}";
+const packageName = "${packageName}";
 
-registerIcon(name, { pathData, ltr, accData });
+registerIcon(name, { pathData, ltr, accData, collection, packageName });
 
 export default { pathData, accData };`;
 
 
+
+const collectionTemplate = (name) => `import { isTheme } from "@ui5/webcomponents-base/dist/config/Theme.js";
+import pathDataV4 from "./v5/${name}.js";
+import pathDataV5 from "./v4/${name}.js";
+const pathData = isTheme("sap_horizon") ? pathDataV5 : pathDataV4;
+export default { pathData };`;
+
+
+const svgTemplate = (pathData) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+	<path d="${pathData}"/>
+</svg>`;
+
 const createIcons = (file) => {
 	const json = JSON.parse(fs.readFileSync(file));
 
@@ -39,16 +58,15 @@ const createIcons = (file) => {
 		const ltr = !!iconData.ltr;
 		const acc = iconData.acc;
 
-		const content = acc ? accTemplate(name, pathData, ltr, acc) : template(name, pathData, ltr);
+		const content = acc ? iconAccTemplate(name, pathData, ltr, acc, json.collection, json.packageName) : iconTemplate(name, pathData, ltr, json.collection, json.packageName);
 
 		fs.writeFileSync(path.join(destDir, `${name}.js`), content);
-	}
+		fs.writeFileSync(path.join(destDir, `${name}.svg`), svgTemplate(pathData));
 
+		if (json.version) {
+			fs.writeFileSync(path.join(path.normalize("dist/"), `${name}.js`), collectionTemplate(name));
+		}
+	}
 };
 
-fs.readdirSync(srcDir).forEach(collectionFile => {
-	createIcons(path.join(srcDir, collectionFile));
-});
-
-
-
+createIcons(srcFile);

package/lib/create-illustrations/index.js

@@ -0,0 +1,95 @@
+const fs = require("fs");
+const path = require("path");
+const mkdirp = require("mkdirp");
+
+if (process.argv.length < 7) {
+	return;
+}
+
+const srcPath = process.argv[2];
+const defaultText = process.argv[3] === "true";
+const illustrationsPrefix = process.argv[4];
+const illustrationSet = process.argv[5];
+const destPath = process.argv[6];
+const fileNamePattern = new RegExp(`${illustrationsPrefix}-.+-(.+).svg`);
+// collect each illustration name because each one should have Sample.js file
+const fileNames = new Set();
+
+const svgImportTemplate = svgContent => { return `export default \`${svgContent}\`;`};
+const svgToJs = fileName => {
+	const svg = fs.readFileSync(path.join(srcPath, fileName), { encoding: "utf-8" });
+	const fileContent = svgImportTemplate(svg);
+	fileName = fileName.replace(/\.svg$/, ".js");
+
+	fs.writeFileSync(path.join(destPath, fileName), fileContent);
+};
+const illustrationImportTemplate = illustrationName => {
+	const illustationNameUpperCase = illustrationName.toUpperCase();
+
+	return defaultText ? `import { registerIllustration } from "@ui5/webcomponents-base/dist/asset-registries/Illustrations.js";
+import dialogSvg from "./${illustrationsPrefix}-Dialog-${illustrationName}.js";
+import sceneSvg from "./${illustrationsPrefix}-Scene-${illustrationName}.js";
+import spotSvg from "./${illustrationsPrefix}-Spot-${illustrationName}.js";
+import {
+	IM_TITLE_${illustationNameUpperCase},
+	IM_SUBTITLE_${illustationNameUpperCase},
+} from "../generated/i18n/i18n-defaults.js";
+
+const name = "${illustrationName}";
+const set = "${illustrationSet}";
+const title = IM_TITLE_${illustationNameUpperCase};
+const subtitle = IM_SUBTITLE_${illustationNameUpperCase};
+
+registerIllustration(name, {
+	dialogSvg,
+	sceneSvg,
+	spotSvg,
+	title,
+	subtitle,
+	set,
+});
+
+export {
+	dialogSvg,
+	sceneSvg,
+	spotSvg,
+};` :
+`import { registerIllustration } from "@ui5/webcomponents-base/dist/asset-registries/Illustrations.js";
+import dialogSvg from "./${illustrationsPrefix}-Dialog-${illustrationName}.js";
+import sceneSvg from "./${illustrationsPrefix}-Scene-${illustrationName}.js";
+import spotSvg from "./${illustrationsPrefix}-Spot-${illustrationName}.js";
+
+const name = "${illustrationName}";
+const set = "${illustrationSet}";
+
+registerIllustration(name, {
+	dialogSvg,
+	sceneSvg,
+	spotSvg,
+	set,
+});
+
+export {
+	dialogSvg,
+	sceneSvg,
+	spotSvg,
+};`
+};
+
+mkdirp.sync(destPath);
+
+const illustrationFileNames = fs.readdirSync(path.normalize(srcPath));
+
+// convert SVG to JS imports
+illustrationFileNames.forEach(illustration => {
+	if (fileNamePattern.test(illustration)) {
+		let [fileName, illustrationName] = illustration.match(fileNamePattern);
+
+		svgToJs(fileName);
+		fileNames.add(illustrationName);
+	}
+});
+
+for (let illustrationName of fileNames) {
+	fs.writeFileSync(path.join(destPath, `${illustrationName}.js`), illustrationImportTemplate(illustrationName));
+}

package/lib/create-new-component/index.js

@@ -61,6 +61,10 @@ class ${componentName} extends UI5Element {
 		return ${componentName}Template;
 	}
 
+	static get dependencies() {
+		return [];
+	}
+
 	static async onDefine() {
 
 	}
@@ -135,8 +139,16 @@ console.log(`Successfully generated ${componentName}.js`);
 console.log(`Successfully generated ${componentName}.css`);
 console.log(`Successfully generated ${componentName}.hbs`);
 
+const bundleLogger = fs.createWriteStream("./bundle.common.js", {
+	flags: "a" // appending
+});
+
+bundleLogger.write(`
+// TODO: Move this line in order to keep the file sorted alphabetically
+import ${componentName} from "./dist/${componentName}.js";`);
+
 // Change the color of the output
-console.warn('\x1b[33m%s\x1b[0m', `
-Please import the generated component in bundle.esm.js:
-import ${componentName} from "./dist/${componentName}.js";
-`);
+	console.warn('\x1b[33m%s\x1b[0m', `
+Component is imported in bundle.common.js.
+Do NOT forget to sort the file in alphabeticall order.
+`);

package/lib/documentation/index.js

@@ -10,8 +10,13 @@ const Handlebars = require('handlebars/dist/handlebars.min.js');
 const fs = require('fs');
 const path = require('path');
 const mkdirp = require('mkdirp');
+const beautify = require("json-beautify");
 
-const api = JSON.parse(fs.readFileSync(path.normalize(process.argv[2])));
+
+const apiJSONPath = path.normalize(process.argv[2]);
+const api = JSON.parse(fs.readFileSync(apiJSONPath));
+
+fs.writeFileSync(apiJSONPath, beautify(api, null, 2, 100));
 
 const entries = api['symbols'];
 const compiledHandlebars = Handlebars.compile(template);
@@ -61,28 +66,40 @@ const appendCSSVarsAPI = entry => {
 	return entry;
 }
 
-const calculateAPI = entry => {
-	if (entriesAPI.indexOf(entry.basename) !== -1) {
-		return entry;
-	}
-
-	let parent = getComponentByName(entry.extends) || {};
-
-	entry = appendCSSVarsAPI(entry);
-	parent = appendCSSVarsAPI(parent);
-
-	parent = { ...{ properties: [], events: [], slots: [], cssVariables: [] }, ...parent };
+const componentHasEntityItem = (component, entity, name) => {
+	return component[entity].some(x => x && x.name === name);
+};
+const removeEmpty = arr => arr.filter(x => x);
 
-	// extend component documentation
-	entry.properties = [...(entry.properties || []), ...(parent.properties || [])];
-	entry.events = [...(entry.events || []), ...(parent.events || [])];
-	entry.slots = [...(entry.slots || []), ...(parent.slots || [])];
-	entry.cssVariables = [...(entry.cssVariables || []), ...(parent.cssVariables || [])];
+const calculateAPI = component => {
+	if (entriesAPI.indexOf(component.basename) !== -1) {
+		return component;
+	}
+	const entities = ["properties", "slots", "events", "methods", "cssVariables"];
+
+	// Initialize all entities with [] if necessary, and remove undefined things, and only leave public things
+	entities.forEach(entity => {
+		component[entity] = removeEmpty(component[entity] || []).filter(x => x.visibility === "public");
+	});
+
+	component = appendCSSVarsAPI(component);
+
+	let parent = getComponentByName(component.extends);
+	if (parent) {
+		let parentComponent = calculateAPI(parent);
+		entities.forEach(entity => {
+			parentComponent[entity].forEach( x => {
+				if (!componentHasEntityItem(component, entity, x.name)) {
+					component[entity].push(x);
+				}
+			});
+		});
+	}
 
-	entriesAPI.push(entry.basename);
+	entriesAPI.push(component.basename);
 
-	return entry;
-}
+	return component;
+};
 
 const appendAdditionalEntriesAPI = entry => {
 	if (entry.appenddocs) {
@@ -107,6 +124,11 @@ const generateSamplePage = entry => {
 	} catch (err) { }
 
 	if (content) {
+		entry.slots.forEach(slotData => {
+			if (!slotData.type.startsWith("Node") && !slotData.type.startsWith("HTMLElement")) { // interface -> don't show in documentation
+				slotData.type = "HTMLElement" + (slotData.type.endsWith("[]") ? "[]" : "");
+			}
+		});
 		const APIReference = compiledHandlebars(entry).replace(/\[\]/g, " [0..n]");
 		const EntitySince = compiledSinceTemplate(entry).replace(/\[\]/g, " [0..n]");
 

package/lib/esm-abs-to-rel/index.js

@@ -0,0 +1,54 @@
+const esprima = require("esprima");
+const escodegen = require("escodegen");
+
+const fs = require("fs");
+const path = require("path");
+const glob = require("glob");
+const basePath = process.argv[2];
+
+const convertImports = (srcPath) => {
+	let changed = false;
+	// console.log("scanning imports of", srcPath);
+	let code = fs.readFileSync(srcPath).toString();
+	const tree = esprima.parseModule(code);
+	const importer = srcPath.replace(basePath, "");
+	const importerDir = path.dirname(importer);
+	// console.log("-> ", importer);
+	tree.body.forEach(node => {
+		if (node.type === "ImportDeclaration") {
+			let importee = node.source.value;
+			if (importee.startsWith(".")) {
+				// add .js extension if missing
+				if (!importee.endsWith(".js")) {
+					node.source.value += ".js"
+					changed = true;
+				}
+				return;
+			}
+			let importeeDir = path.dirname(importee);
+			let importeeFile = path.basename(importee);
+			let relativePath = path.relative(importerDir, importeeDir);
+			if (relativePath.length === 0) {
+				relativePath = "."
+			}
+			if (!relativePath.startsWith(".")) {
+				relativePath = "./" + relativePath;
+			}
+
+			relativePath = relativePath.replace(/\\/g, "/"); // the browser expects unix paths
+			let relativeImport = `${relativePath}/${importeeFile}.js`;
+			// console.log(importee + " --> " + relativeImport);
+			node.source.value = relativeImport;
+			changed = true;
+		}
+	});
+
+	if (changed) {
+		fs.writeFileSync(srcPath, escodegen.generate(tree));
+	}
+}
+
+const fileNames = glob.sync(basePath + "**/*.js");
+// console.log(fileNames);
+fileNames.forEach(convertImports);
+console.log("Success: Converted absolute imports to relative for files in:", basePath)

package/lib/generate-json-imports/i18n.js

@@ -1,38 +1,37 @@
 const fs = require("fs");
 const path = require('path');
 const mkdirp = require("mkdirp");
-const assets = require("../../assets-meta.js");
 
 const packageName = JSON.parse(fs.readFileSync("package.json")).name;
 
 const inputFolder = path.normalize(process.argv[2]);
-const outputFile = path.normalize(`${process.argv[3]}/i18n.js`);
-
-const defaultLanguage = assets.languages.default;
+const outputFile = path.normalize(`${process.argv[3]}/i18n-static.js`);
+const outputFileDynamic = path.normalize(`${process.argv[3]}/i18n.js`);
 
 // All languages present in the file system
 const files = fs.readdirSync(inputFolder);
 const languages = files.map(file => {
-  const matches = file.match(/messagebundle_(.+?).json$/);
-  return matches ? matches[1] : undefined;
-}).filter(key => !!key && key !== defaultLanguage);
+	const matches = file.match(/messagebundle_(.+?).json$/);
+	return matches ? matches[1] : undefined;
+}).filter(key => !!key);
 
-let content;
+let contentStatic, contentDynamic;
 
 // No i18n - just import dependencies, if any
 if (languages.length === 0) {
-  content = ``;
+  contentStatic = "";
+  contentDynamic = "";
 // There is i18n - generate the full file
 } else {
+	// Keys for the array
+	const languagesKeysString = languages.map(key => `"${key}": _${key},`).join("\n\t");
+	const languagesKeysStringArray = languages.map(key => `"${key}",`).join("\n\t");
 
-  // Keys for the array
-  const languagesKeysString = languages.map(key => `${key},`).join("\n\t");
-
-  // Actual imports for json assets
-  const assetsImportsString = languages.map(key => `import ${key} from "../assets/i18n/messagebundle_${key}.json";`).join("\n");
+	// Actual imports for json assets
+	const assetsImportsString = languages.map(key => `import _${key} from "../assets/i18n/messagebundle_${key}.json";`).join("\n");
 
-  // Resulting file content
-  content = `import { registerI18nBundle } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
+	// static imports
+	contentStatic = `import { registerI18nLoader } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
 
 ${assetsImportsString}
 
@@ -40,17 +39,53 @@ const bundleMap = {
 	${languagesKeysString}
 };
 
-const allEntriesInlined = Object.entries(bundleMap).every(([_key, value]) => typeof (value) === "object");
-
-if (allEntriesInlined) {
-	console.warn(\`Inefficient bundling detected: consider bundling i18n imports as URLs instead of inlining them.
-See rollup-plugin-url or webpack file-loader for more information.
-Suggested pattern: "assets\\\\\\/.*\\\\\\.json"\`);
+const fetchMessageBundle = async (localeId) => {
+	if (typeof bundleMap[localeId] === "object") {
+		// inlined from build
+		throw new Error("[i18n] Inlined JSON not supported with static imports of assets. Use dynamic imports of assets or configure JSON imports as URLs")
+	}
+	return (await fetch(bundleMap[localeId])).json()
 }
 
-registerI18nBundle("${packageName}", bundleMap);
+const localeIds = [${languagesKeysStringArray}];
+
+localeIds.forEach(localeId => {
+	registerI18nLoader("${packageName}", localeId, fetchMessageBundle);
+});
 `;
+
+	// Actual imports for json assets
+	const dynamicImportsString = languages.map(key => `		case "${key}": return (await import("../assets/i18n/messagebundle_${key}.json")).default;`).join("\n");
+
+	// Resulting file content
+	contentDynamic = `import { registerI18nLoader } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
+
+	const importMessageBundle = async (localeId) => {
+		switch (localeId) {
+	${dynamicImportsString}
+			default: throw "unknown locale"
+		}
+	}
+
+	const importAndCheck = async (localeId) => {
+		const data = await importMessageBundle(localeId);
+		if (typeof data === "string" && data.endsWith(".json")) {
+			throw new Error(\`[i18n] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build or use 'import ".../Assets-static.js"'. Check the \"Assets\" documentation for more information.\`);
+		}
+		return data;
+	}
+
+	const localeIds = [${languagesKeysStringArray}];
+
+	localeIds.forEach(localeId => {
+		registerI18nLoader("${packageName}", localeId, importAndCheck);
+	});
+	`;
+
+
 }
 
+
 mkdirp.sync(path.dirname(outputFile));
-fs.writeFileSync(outputFile, content);
+fs.writeFileSync(outputFile, contentStatic);
+fs.writeFileSync(outputFileDynamic, contentDynamic);

package/lib/generate-json-imports/themes.js

@@ -4,39 +4,70 @@ const mkdirp = require("mkdirp");
 const assets = require("../../assets-meta.js");
 
 const inputFolder = path.normalize(process.argv[2]);
-const outputFile = path.normalize(`${process.argv[3]}/Themes.js`);
+const outputFile = path.normalize(`${process.argv[3]}/Themes-static.js`);
+const outputFileDynamic = path.normalize(`${process.argv[3]}/Themes.js`);
 
 // All supported optional themes
-const optionalThemes = assets.themes.all.filter(theme => theme !== assets.themes.default);
+const allThemes = assets.themes.all;
 
 // All themes present in the file system
 const dirs = fs.readdirSync(inputFolder);
 const themesOnFileSystem = dirs.map(dir => {
 	const matches = dir.match(/sap_.*$/);
 	return matches ? dir : undefined;
-}).filter(key => !!key && optionalThemes.includes(key));
+}).filter(key => !!key && allThemes.includes(key));
 
 const packageName = JSON.parse(fs.readFileSync("package.json")).name;
 
 const importLines = themesOnFileSystem.map(theme => `import ${theme} from "../assets/themes/${theme}/parameters-bundle.css.json";`).join("\n");
-const isInlinedCondition = themesOnFileSystem.map(theme => `isInlined(${theme})`).join(" || ");
-const registerLines = themesOnFileSystem.map(theme => `registerThemeProperties("${packageName}", "${theme}", ${theme});`).join("\n");
+const themeUrlsByName = "{\n" + themesOnFileSystem.join(",\n") + "\n}";
+const availableThemesArray = `[${themesOnFileSystem.map(theme => `"${theme}"`).join(", ")}]`;
+const dynamicImportLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await import("../assets/themes/${theme}/parameters-bundle.css.json")).default;`).join("\n");
 
-// Resulting file content
-const content = `import { registerThemeProperties } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
+
+// static imports file content
+const contentStatic = `import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
 
 ${importLines}
 
+const themeUrlsByName = ${themeUrlsByName};
 const isInlined = obj => typeof (obj) === "object";
 
-if (${isInlinedCondition}) {
-	console.warn(\`Inefficient bundling detected: consider bundling theme properties imports as URLs instead of inlining them.
-See rollup-plugin-url or webpack file-loader for more information.
-Suggested pattern: "assets\\\\\\/.*\\\\\\.json"\`);
+const loadThemeProperties = async (themeName) => {
+	if (typeof themeUrlsByName[themeName] === "object") {
+		// inlined from build
+		throw new Error("[themes] Inlined JSON not supported with static imports of assets. Use dynamic imports of assets or configure JSON imports as URLs");
+	}
+	return (await fetch(themeUrlsByName[themeName])).json();
+}
+
+${availableThemesArray}
+  .forEach(themeName => registerThemePropertiesLoader("${packageName}", themeName, loadThemeProperties));
+`;
+
+
+// dynamic imports file content
+const contentDynamic = `import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
+
+const loadThemeProperties = async (themeName) => {
+	switch (themeName) {
+${dynamicImportLines}
+		default: throw "unknown theme"
+	}
+}
+
+const loadAndCheck = async (themeName) => {
+	const data = await loadThemeProperties(themeName);
+	if (typeof data === "string" && data.endsWith(".json")) {
+		throw new Error(\`[themes] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build or use 'import ".../Assets-static.js"'. Check the \"Assets\" documentation for more information.\`);
+	}
+	return data;
 }
 
-${registerLines}
+${availableThemesArray}
+  .forEach(themeName => registerThemePropertiesLoader("${packageName}", themeName, loadAndCheck));
 `;
 
 mkdirp.sync(path.dirname(outputFile));
-fs.writeFileSync(outputFile, content);
+fs.writeFileSync(outputFile, contentStatic);
+fs.writeFileSync(outputFileDynamic, contentDynamic);

package/lib/hash/config.js

@@ -0,0 +1,10 @@
+const config = {
+	files: {
+		exclude: ['serve.json']
+	},
+	folders: {
+		exclude: ['resources']
+	},
+};
+
+module.exports = config;

package/lib/hash/generate.js

@@ -0,0 +1,19 @@
+const fs = require("fs");
+const path = require("path");
+const process = require("process");
+const { hashElement } = require("folder-hash");
+const config = require("./config.js");
+
+const inputDir = path.normalize(process.argv[2]);
+const outputFileName = path.normalize(process.argv[3]);
+
+const generateHash = async (inputDir, outputFileName) => {
+	const result = await hashElement(inputDir, config);
+	const hash = result.hash;
+	fs.writeFileSync(outputFileName, hash);
+	return hash;
+};
+
+generateHash(inputDir, outputFileName).then(hash => {
+	console.log(`Generated hash: ${hash}`);
+});

package/lib/hash/upToDate.js

@@ -0,0 +1,31 @@
+const fs = require("fs");
+const path = require("path");
+const process = require("process");
+const { hashElement } = require("folder-hash");
+const config = require("./config.js");
+
+const inputDir = path.normalize(process.argv[2]);
+const hashFileName = path.normalize(process.argv[3]);
+
+const isUpToDate = async (inputDir, hashFileName) => {
+	// No dist/ directory or no hash file
+	if (!fs.existsSync(inputDir) || !fs.existsSync(hashFileName)) {
+		return false;
+	}
+
+	// Empty hash file
+	const existingHash = `${fs.readFileSync(hashFileName)}`;
+	if (!existingHash) {
+		return false;
+	}
+
+	// Calculate the hash of the dist/ directory
+	const result = await hashElement(inputDir, config);
+	const newHash = result.hash;
+
+	return newHash === existingHash;
+};
+
+isUpToDate(inputDir, hashFileName).then(upToDate => {
+	process.exit(upToDate ? 0 : 1); // 0 means success (it is up to date), 1 means failure (must rebuild the dist/)
+});