@ui5/webcomponents-tools 0.0.0-fa45f79f6 → 0.0.0-fc993d8cd

package/lib/postcss-combine-duplicated-selectors/index.js

@@ -0,0 +1,178 @@
+/*
+ The MIT License (MIT)
+
+Copyright (c) 2016 Christian Murphy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+const parser = require('postcss-selector-parser');
+const name = "postcss-combine-duplicated-selectors";
+
+/**
+ * Ensure that attributes with different quotes match.
+ * @param {Object} selector - postcss selector node
+ */
+function normalizeAttributes(selector) {
+	selector.walkAttributes((node) => {
+		if (node.value) {
+			// remove quotes
+			node.value = node.value.replace(/'|\\'|"|\\"/g, '');
+		}
+	});
+}
+
+/**
+ * Sort class and id groups alphabetically
+ * @param {Object} selector - postcss selector node
+ */
+function sortGroups(selector) {
+	selector.each((subSelector) => {
+		subSelector.nodes.sort((a, b) => {
+			// different types cannot be sorted
+			if (a.type !== b.type) {
+				return 0;
+			}
+
+			// sort alphabetically
+			return a.value < b.value ? -1 : 1;
+		});
+	});
+
+	selector.sort((a, b) => (a.nodes.join('') < b.nodes.join('') ? -1 : 1));
+}
+
+/**
+ * Remove duplicated properties
+ * @param {Object} selector - postcss selector node
+ * @param {Boolean} exact
+ */
+function removeDupProperties(selector, exact) {
+	if (!exact) { // Remove duplicated properties, regardless of value
+		const retainedProps = new Set();
+
+		for (let actIndex = selector.nodes.length - 1; actIndex >= 1; actIndex--) {
+			const prop = selector.nodes[actIndex].prop;
+			if (prop !== undefined) {
+				if (!retainedProps.has(prop)) {
+					retainedProps.add(prop); // Mark the prop as retained, all other occurrences must be removed
+				} else {
+					selector.nodes[actIndex].remove(); // This occurrence of the prop must be removed
+				}
+			}
+		}
+	} else {
+		// Remove duplicated properties from bottom to top ()
+		for (let actIndex = selector.nodes.length - 1; actIndex >= 1; actIndex--) {
+			for (let befIndex = actIndex - 1; befIndex >= 0; befIndex--) {
+				if (
+					selector.nodes[actIndex].prop === selector.nodes[befIndex].prop &&
+					selector.nodes[actIndex].value === selector.nodes[befIndex].value
+				) {
+					selector.nodes[befIndex].remove();
+					actIndex--;
+				}
+			}
+		}
+	}
+}
+
+const uniformStyle = parser((selector) => {
+	normalizeAttributes(selector);
+	sortGroups(selector);
+});
+
+const defaultOptions = {
+	removeDuplicatedProperties: false,
+};
+
+module.exports = (options) => {
+	options = Object.assign({}, defaultOptions, options);
+	return {
+		postcssPlugin: name,
+		prepare() {
+			// Create a map to store maps
+			const mapTable = new Map();
+			// root map to store root selectors
+			mapTable.set('root', new Map());
+
+			return {
+				Rule: (rule) => {
+					let map;
+					// Check selector parent for any at rule
+					if (rule.parent.type === 'atrule') {
+						// Use name and query params as the key
+						const query =
+							rule.parent.name.toLowerCase() +
+							rule.parent.params.replace(/\s+/g, '');
+
+						// See if this query key is already in the map table
+						map = mapTable.has(query) ? // If it is use it
+							mapTable.get(query) : // if not set it and get it
+							mapTable.set(query, new Map()).get(query);
+					} else {
+						// Otherwise we are dealing with a selector in the root
+						map = mapTable.get('root');
+					}
+
+					// create a uniform selector
+					const selector = uniformStyle.processSync(rule.selector, {
+						lossless: false,
+					});
+
+					if (map.has(selector)) {
+						// store original rule as destination
+						const destination = map.get(selector);
+
+						// check if node has already been processed
+						if (destination === rule) return;
+
+						// move declarations to original rule
+						while (rule.nodes.length > 0) {
+							destination.append(rule.nodes[0]);
+						}
+						// remove duplicated rule
+						rule.remove();
+
+						if (
+							options.removeDuplicatedProperties ||
+							options.removeDuplicatedValues
+						) {
+							removeDupProperties(
+								destination,
+								options.removeDuplicatedValues,
+							);
+						}
+					} else {
+						if (
+							options.removeDuplicatedProperties ||
+							options.removeDuplicatedValues
+						) {
+							removeDupProperties(rule, options.removeDuplicatedValues);
+						}
+						// add new selector to symbol table
+						map.set(selector, rule);
+					}
+				},
+			};
+		},
+	};
+};
+
+module.exports.postcss = true;

package/lib/postcss-css-to-esm/index.js

@@ -1,33 +1,90 @@
-const postcss = require('postcss');
 const fs = require('fs');
 const path = require('path');
 const mkdirp = require('mkdirp');
+const assets = require("../../assets-meta.js");
 
-const getDefaultThemeCode = packageName => {
-	return `import "@ui5/webcomponents-theme-base/dist/DefaultTheme.js";
-	
-import { registerThemeProperties } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
+const DEFAULT_THEME = assets.themes.default;
 
-import fiori3 from "./sap_fiori_3/parameters-bundle.css.js";
+const getDefaultThemeCode = packageName => {
+	return `import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
 
-registerThemeProperties("${packageName}", "sap_fiori_3", fiori3);
+import defaultThemeBase from "@ui5/webcomponents-theming/dist/generated/themes/${DEFAULT_THEME}/parameters-bundle.css.js";
+import defaultTheme from "./${DEFAULT_THEME}/parameters-bundle.css.js";
 
+registerThemePropertiesLoader("@ui5/webcomponents-theming", "${DEFAULT_THEME}", async () => defaultThemeBase);
+registerThemePropertiesLoader("${packageName}", "${DEFAULT_THEME}", async () => defaultTheme);
 `;
 };
 
-module.exports = postcss.plugin('add css to esm transform plugin', function (opts) {
+const getFileContent = (tsMode, targetFile, packageName, css, includeDefaultTheme) => {
+	if (tsMode) {
+		return getTSContent(targetFile, packageName, css, includeDefaultTheme);
+	}
+
+	return getJSContent(targetFile, packageName, css, includeDefaultTheme);
+}
+
+const getTSContent = (targetFile, packageName, css, includeDefaultTheme) => {
+	const typeImport = "import type { StyleData } from \"@ui5/webcomponents-base/dist/types.js\";"
+	const defaultTheme = includeDefaultTheme ? getDefaultThemeCode(packageName) : "";
+
+	// tabs are intentionally mixed to have proper identation in the produced file
+	return `${typeImport}
+${defaultTheme}
+const styleData: StyleData = {packageName:"${packageName}",fileName:"${targetFile.substr(targetFile.lastIndexOf("themes"))}",content:${css}};
+export default styleData;
+	`;
+}
+
+const getJSContent = (targetFile, packageName, css, includeDefaultTheme) => {
+	const defaultTheme = includeDefaultTheme ? getDefaultThemeCode(packageName) : "";
+
+	return `${defaultTheme}export default {packageName:"${packageName}",fileName:"${targetFile.substr(targetFile.lastIndexOf("themes"))}",content:${css}}`
+}
+
+
+const proccessCSS = css => {
+	css = css.replace(/\.sapThemeMeta[\s\S]*?:root/, ":root");
+	css = css.replace(/\.background-image.*{.*}/, "");
+	css = css.replace(/\.sapContrast[ ]*:root[\s\S]*?}/, "");
+	css = css.replace(/--sapFontUrl.*\);?/, "");
+	return JSON.stringify(css);
+}
+
+module.exports = function (opts) {
 	opts = opts || {};
 
-	return function (root) {
-		const css = JSON.stringify(root.toString());
-		const targetFile = root.source.input.from.replace(`/${opts.toReplace}/`, "/dist/generated/").replace(`\\${opts.toReplace}\\`, "\\dist\\generated\\");
+	const packageName = opts.packageName;
+	const includeDefaultTheme = opts.includeDefaultTheme;
+	const toReplace = opts.toReplace;
 
-		mkdirp.sync(path.dirname(targetFile));
+	return {
+		postcssPlugin: 'postcss-css-to-esm',
+		Once (root) {
+			const tsMode = process.env.UI5_TS === "true";
 
-		const filePath = `${targetFile}.js`;
+			let css = root.toString();
+			css = proccessCSS(css);
 
-		const defaultTheme = opts.includeDefaultTheme ? getDefaultThemeCode(opts.packageName) : ``;
+			const targetFile = root.source.input.from.replace(`/${toReplace}/`, "/src/generated/").replace(`\\${toReplace}\\`, "\\src\\generated\\");
+			mkdirp.sync(path.dirname(targetFile));
 
-		fs.writeFileSync(filePath, `${defaultTheme}export default ${css};`);
-	}
-});
+			const filePath = `${targetFile}.${tsMode ? "ts" : "js"}`;
+		
+			// it seems slower to read the old content, but writing the same content with no real changes
+			// (as in initial build and then watch mode) will cause an unnecessary dev server refresh
+			let oldContent = "";
+			try {
+				oldContent = fs.readFileSync(filePath).toString();
+			} catch (e) {
+				// file not found
+			}
+
+			const content = getFileContent(tsMode, filePath, packageName, css, includeDefaultTheme);
+			if (content !== oldContent) {
+				fs.writeFileSync(filePath, content);
+			}
+		}
+	};
+};
+module.exports.postcss = true;

package/lib/postcss-css-to-json/index.js

@@ -1,20 +1,47 @@
-const postcss = require('postcss');
 const fs = require('fs');
 const path = require('path');
 const mkdirp = require('mkdirp');
 
-module.exports = postcss.plugin('add css to JSON transform plugin', function (opts) {
-	opts = opts || {};
+const proccessCSS = css => {
+	css = css.replace(/\.sapThemeMeta[\s\S]*?:root/, ":root");
+	css = css.replace(/\.background-image.*{.*}/, "");
+	css = css.replace(/\.sapContrast[ ]*:root[\s\S]*?}/, "");
+	css = css.replace(/--sapFontUrl.*\);?/, "");
+	return css;
+}
 
-	return function (root) {
-		const css = root.toString();
-		const targetFile = root.source.input.from.replace(`/${opts.toReplace}/`, "/dist/generated/assets/").replace(`\\${opts.toReplace}\\`, "\\dist\\generated\\assets\\");
+module.exports = function (opts) {
+	opts = opts || {};
 
-		mkdirp.sync(path.dirname(targetFile));
+	return {
+		postcssPlugin: 'postcss-css-to-json',
+		Once (root) {
+			let css = root.toString();
+			css = proccessCSS(css);
 
-		const filePath = `${targetFile}.json`;
+			const targetFile = root.source.input.from.replace(`/${opts.toReplace}/`, "/dist/generated/assets/").replace(`\\${opts.toReplace}\\`, "\\dist\\generated\\assets\\");
+			mkdirp.sync(path.dirname(targetFile));
 
-		fs.writeFileSync(filePath, JSON.stringify({_: css}));
+			const filePath = `${targetFile}.json`;
+			const data = {
+				packageName: opts.packageName,
+				fileName: targetFile.substr(targetFile.lastIndexOf("themes")),
+				content: css
+			};
+			// it seems slower to read the old content, but writing the same content with no real changes
+			// (as in initial build and then watch mode) will cause an unnecessary dev server refresh
+			let oldContent = "";
+			try {
+				oldContent = fs.readFileSync(filePath).toString();
+			} catch (e) {
+				// file not found
+			}
+			const content = JSON.stringify({_: data});
+			if (content !== oldContent) {
+				fs.writeFileSync(filePath, content);
+			}
+		}
+	};
+};
 
-	}
-});
+module.exports.postcss = true;

package/lib/postcss-new-files/index.js

@@ -0,0 +1,36 @@
+const chokidar = require("chokidar");
+const commandLineArgs = require("command-line-args");
+const { exec } = require("child_process");
+
+const options = commandLineArgs([
+	{ name: "srcFiles", type: String },
+]);
+
+const runPostcss = path => {
+	let command = `postcss ${path} --config config/postcss.components --base src --dir dist/css/`;
+	console.log(`Executing: ${command}`);
+	exec(command, (err, stdout, stderr) => {
+		if (err) {
+			console.log(`Could not run postcss for ${path}. Error: ${err}`);
+		}
+	});
+
+	command = `${command} -w`;
+	console.log(`Executing: ${command}`);
+	exec(command, (err, stdout, stderr) => {
+		if (err) {
+			console.log(`Could not run postcss in watch mode for ${path}. Error: ${err}`);
+		}
+	});
+};
+
+let ready = false; // Do nothing until the ready event has been fired (we don't want to recompile all files initially)
+const watcher = chokidar.watch(options.srcFiles);
+watcher.on("ready", () => {
+	ready = true; // Initial scan is over -> waiting for new files
+});
+watcher.on("add", path => {
+	if (ready) {
+		runPostcss(path);
+	}
+});

package/lib/postcss-p/postcss-p.mjs

@@ -0,0 +1,14 @@
+import 'zx/globals';
+
+// don't print executed commands and their output
+$.verbose = false;
+
+const inputFiles = await globby("src/**/parameters-bundle.css");
+
+const restArgs = process.argv.slice(2);
+
+// run all postcss processes in parallel as passing the glob directly to postcss makes them processed sequentially.
+// and the amount of imports give a big speed up when run in parallel
+await Promise.all(inputFiles.map(file => {
+  return $`postcss ${file} --config config/postcss.themes --base src --dir dist/css/ ${restArgs}`;
+}));

package/lib/replace-global-core/index.js

@@ -0,0 +1,25 @@
+const fs = require("fs").promises;
+
+const basePath = process.argv[2];
+
+const replaceGlobalCoreUsage = async (srcPath) => {
+
+	const original = (await fs.readFile(srcPath)).toString();
+	let replaced = original.replace(/sap\.ui\.getCore\(\)/g, `Core`);
+
+	if (original !== replaced) {
+		replaced = `import Core from 'sap/ui/core/Core';
+		${replaced}`;
+		return fs.writeFile(srcPath, replaced);
+	}
+};
+
+const generate = async () => {
+	const { globby } = await import("globby");
+	const fileNames = await globby(basePath + "**/*.js");
+	return Promise.all(fileNames.map(replaceGlobalCoreUsage).filter(x => !!x));
+};
+
+generate().then(() => {
+	console.log("Success: Replaced global core usage in:", basePath);
+});

package/lib/scoping/get-all-tags.js

@@ -0,0 +1,37 @@
+const fs = require("fs");
+const path = require("path");
+const glob = require("glob");
+
+const getTag = file => {
+	const fileContent = String(fs.readFileSync(file)).replace(/\n/g, "");
+	const matches = fileContent.match(/\btag\b:\s*\"(.*?)\"/);
+	return matches ? matches[1] : undefined;
+};
+
+const getPackageTags = (packageDir) => {
+	const srcDir = path.join(packageDir, "src/");
+	return glob.sync(path.join(srcDir, "/**/*.js")).flatMap(file => {
+		const tag = getTag(file);
+		return [tag];
+	}).filter(item => !!item);
+};
+
+const isComponentsPackage = (packageFileContent) => {
+	return packageFileContent.ui5 && packageFileContent.ui5.webComponentsPackage;
+};
+
+const getDepComponentPackages = packageDir => {
+	const packageFile = path.join(packageDir, "package.json");
+	const packageFileContent = JSON.parse(fs.readFileSync(packageFile));
+	if (!isComponentsPackage(packageFileContent)) {
+		return [];
+	}
+
+	return Object.keys(packageFileContent.dependencies || {}).map(dep => path.dirname(require.resolve(path.join(dep, "package.json"))));
+};
+
+const getAllTags = (packageDir) => {
+	return getPackageTags(packageDir).concat(getDepComponentPackages(packageDir).flatMap(getPackageTags));
+};
+
+module.exports = getAllTags;

package/lib/scoping/lint-src.js

@@ -0,0 +1,31 @@
+const fs = require("fs");
+const path = require("path");
+const glob = require("glob");
+const getAllTags = require("./get-all-tags.js");
+
+const tags = getAllTags(process.cwd());
+
+const errors = [];
+
+glob.sync(path.join(process.cwd(), "src/**/*.css")).forEach(file => {
+	let content = String(fs.readFileSync(file));
+	tags.forEach(tag => {
+		if (content.match(new RegExp(`(^|[^\.\-_A-Za-z0-9"\[])(${tag})([^\-_A-Za-z0-9]|$)`, "g"))) {
+			errors.push(`Warning! ${tag} found in ${file}`);
+		}
+	});
+});
+
+glob.sync(path.join(process.cwd(), "src/**/*.js")).forEach(file => {
+	let content = String(fs.readFileSync(file));
+	tags.forEach(tag => {
+		if (content.match(new RegExp(`querySelector[A-Za-z]*..${tag}`, "g"))) {
+			errors.push(`Warning! querySelector for ${tag} found in ${file}`);
+		}
+	});
+});
+
+if (errors.length) {
+	errors.forEach(error => console.log(error));
+	throw new Error("Errors found.");
+}

package/lib/scoping/missing-dependencies.js

@@ -0,0 +1,65 @@
+const fs = require("fs");
+const glob = require("glob");
+const path = require("path");
+const process = require("process");
+
+const projectPath = process.argv[2];
+
+// gather all tags from all files
+const tagsToFiles = new Map();
+const filesToTags = new Map();
+
+let files = [
+	...glob.sync(path.join("packages/main/src/**/*.js")),
+	...glob.sync(path.join("packages/fiori/src/**/*.js")),
+];
+files.forEach(file => {
+	let matches = file.match(/([a-zA-Z0-9_]+)\.js$/);
+	const name = matches[1];
+
+	const content = `${fs.readFileSync(file)}`;
+	matches = content.match(/tag: "(.*?)",/);
+	if (matches) {
+		const tag = matches[1];
+		tagsToFiles.set(tag, name);
+		filesToTags.set(name, tag);
+	}
+});
+
+// Process the package
+files = glob.sync(path.join(projectPath, "src/**/*.js"));
+tagsToFiles.forEach((file, tag) => {
+	const sourcePath = path.join(projectPath, "src/", `${file}.js`);
+	if (!fs.existsSync(sourcePath)) {
+		return;
+	}
+	const sourceContent = `${fs.readFileSync(sourcePath)}`.split("\n").join(" ");
+
+	const hbsPath = path.join(projectPath, "src/", `${file}.hbs`);
+	const hbsContent = fs.existsSync(hbsPath) ? `${fs.readFileSync(hbsPath)}` : "";
+
+	const hbsPopoverPath = path.join(projectPath, "src/", `${file}Popover.hbs`);
+	const hbsPopoverContent = fs.existsSync(hbsPopoverPath) ? `${fs.readFileSync(hbsPopoverPath)}` : "";
+
+	// deps
+	let deps = [];
+	let matches = sourceContent.match(/static get dependencies\(\) \{\s+return \[(.*?)\]/);
+	if (matches) {
+		deps = matches[1].split(",").map(x => x.trim()).filter(x => !!x);
+	}
+
+	// tags
+	matches = [
+		...hbsContent.matchAll(/<ui5-[a-z0-9-]+/g),
+		...hbsPopoverContent.matchAll(/<ui5-[a-z0-9-]+/g),
+	];
+	if (matches) {
+		matches.forEach(match => {
+			const tagUsed = match[0].substr(1);
+			const dep = tagsToFiles.get(tagUsed);
+			if (!deps.includes(dep)) {
+				console.log(`${file} used ${tagUsed}`);
+			}
+		});
+	}
+});

package/lib/scoping/report-tags-usage.js

@@ -0,0 +1,28 @@
+const fs = require("fs");
+const glob = require("glob");
+const path = require("path");
+const process = require("process");
+
+// gather all tags from all files
+const tags = new Set();
+const files = glob.sync(path.join(process.argv[2], "src/**/*.js"));
+files.forEach(file => {
+	const content = `${fs.readFileSync(file)}`;
+	const matches = content.match(/tag: "(.*?)",/);
+	if (matches) {
+		tags.add(matches[1]);
+	}
+});
+
+// report all usages of any tag within any file, which is not the tag definition and is not hasAttribute
+files.forEach(file => {
+	const content = `${fs.readFileSync(file)}`;
+	const lines = content.split("\n");
+	lines.forEach(line => {
+		tags.forEach(tag => {
+			if (line.includes(`"${tag}"`) && !line.includes(`tag: "${tag}",`) && !line.includes(`hasAttribute("${tag}")`)) {
+				console.log(`${file}: ${line.trim()}`);
+			}
+		});
+	});
+});

package/lib/scoping/scope-test-pages.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+const path = require("path");
+const glob = require("glob");
+const getAllTags = require("./get-all-tags.js");
+
+const root = process.argv[2];
+const suffix = process.argv[3];
+
+const tags = getAllTags(process.cwd());
+
+// Replaces tags in HTML content, f.e. <ui5-button> with <ui5-button-ver> or </ui5-button> with </ui5-button-ver>
+const replaceTagsHTML = content => {
+	tags.forEach(tag => {
+		content = content.replace(new RegExp(`(<\/?)(${tag})(\/?[> \t\n])`, "g"), `$1$2-${suffix}$3`);
+	});
+	return content;
+};
+
+// Replace tags in any content
+const replaceTagsAny = content => {
+	tags.forEach(tag => {
+		content = content.replace(new RegExp(`(^|[^\-_A-Za-z0-9])(${tag})([^\-_A-Za-z0-9]|$)`, "g"), `$1$2-${suffix}$3`);
+	});
+	return content;
+};
+
+// Replace bundle names and HTML tag names in test pages
+glob.sync(path.join(root, "/**/*.html")).forEach(file => {
+	let content = String(fs.readFileSync(file));
+	content = content.replace(/bundle\.(.*?)\.js/g, `../bundle.scoped.$1.js`);
+	content = replaceTagsHTML(content);
+	fs.writeFileSync(file, content);
+});
+
+// Replace tag names everywhere
+glob.sync(path.join(root, "/**/*.{html,css,js}")).forEach(file => {
+	let content = String(fs.readFileSync(file));
+	content = replaceTagsAny(content);
+	fs.writeFileSync(file, content);
+});