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

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

@@ -1,8 +1,31 @@
 const fs = require("fs");
+const path = require("path");
 const prompts = require("prompts");
 const jsFileContentTemplate = require("./jsFileContentTemplate.js");
 const tsFileContentTemplate = require("./tsFileContentTemplate.js");
 
+/**
+ * Hyphanates the given PascalCase string, f.e.:
+ * Foo -> "my-foo" (adds preffix)
+ * FooBar -> "foo-bar"
+ */
+const hyphaneteComponentName = (componentName) => {
+	const result = componentName.replace(/([a-z])([A-Z])/g, '$1-$2' ).toLowerCase();
+
+	return result.includes("-") ? result : `my-${result}`;
+};
+
+/**
+ * Capitalizes first letter of string.
+ */
+const capitalizeFirstLetter = string => string.charAt(0).toUpperCase() + string.slice(1);
+
+/**
+ * Validates component name, enforcing PascalCase pattern - Button, MyButton.
+ */
+const PascalCasePattern = /^[A-Z][A-Za-z0-9]+$/;
+const isNameValid = name => typeof name === "string" && PascalCasePattern.test(name);
+
 const getPackageName = () => {
 	if (!fs.existsSync("./package.json")) {
 		throw("The current directory doesn't contain package.json file.");
@@ -35,13 +58,6 @@ const getLibraryName = packageName => {
 	return packageName.substr("webcomponents-".length);
 };
 
-// String manipulation
-const capitalizeFirstLetter = string => string.charAt(0).toUpperCase() + string.slice(1);
-
-// Validation of user input
-const isNameValid = name => typeof name === "string" && name.match(/^[a-zA-Z][a-zA-Z0-9_-]*$/);
-const isTagNameValid = tagName => tagName.match(/^([a-z][a-z0-9]*-)([a-z0-9]+(-[a-z0-9]+)*)$/);
-
 const generateFiles = (componentName, tagName, library, packageName, isTypeScript) => {
 	componentName = capitalizeFirstLetter(componentName);
 	const filePaths = {
@@ -67,7 +83,7 @@ const generateFiles = (componentName, tagName, library, packageName, isTypeScrip
 	// Change the color of the output
 	console.warn('\x1b[33m%s\x1b[0m', `
 	Make sure to import the component in your bundle by using:
-	import ${componentName} from "./dist/${componentName}.js";`);
+	import "./dist/${componentName}.js";`);
 }
 
 // Main function
@@ -77,21 +93,9 @@ const createWebComponent = async () => {
 
 	const consoleArguments = process.argv.slice(2);
 	let componentName = consoleArguments[0];
-	let tagName = consoleArguments[1];
-	let language = consoleArguments[2];
-	let isTypeScript;
-
 
 	if (componentName && !isNameValid(componentName)) {
-		throw new Error("Invalid component name. Please use only letters, numbers, dashes and underscores. The first character must be a letter.");
-	}
-
-	if (tagName && !isTagNameValid(tagName)) {
-		throw new Error("Invalid tag name. The tag name should only contain lowercase letters, numbers, dashes, and underscores. The first character must be a letter, and it should follow the pattern 'tag-name'.");
-	}
-
-	if (language && language !== "typescript" && language !== "ts" && language !== "javascript" && language !== "js") {
-		throw new Error("Invalid language. Please use 'typescript','javascript' or their respective 'ts','js'.");
+		throw new Error(`${componentName} is invalid component name. Use only letters (at least two) and start with capital one:  Button, MyButton, etc.`);
 	}
 
 	if (!componentName) {
@@ -99,7 +103,7 @@ const createWebComponent = async () => {
 			type: "text",
 			name: "componentName",
 			message: "Please enter a component name:",
-			validate: (value) => isNameValid(value),
+			validate: (value) => isNameValid(value) ? true : "Component name should follow PascalCase naming convention (f.e. Button, MyButton, etc.).",
 		});
 		componentName = response.componentName;
 
@@ -108,42 +112,8 @@ const createWebComponent = async () => {
 		}
 	}
 
-	if (!tagName) {
-		const response = await prompts({
-			type: "text",
-			name: "tagName",
-			message: "Please enter a tag name:",
-			validate: (value) => isTagNameValid(value),
-		});
-		tagName = response.tagName;
-
-		if (!tagName) {
-			process.exit();
-		}
-	}
-
-	if (!language) {
-		const response = await prompts({
-			type: "select",
-			name: "isTypeScript",
-			message: "Please select a language:",
-			choices: [
-				{
-					title: "TypeScript (recommended)",
-					value: true,
-				},
-				{
-					title: "JavaScript",
-					value: false,
-				},
-			],
-		});
-		isTypeScript = response.isTypeScript;
-	} else if (language === "typescript" || language === "ts") {
-		isTypeScript = true;
-	} else {
-		isTypeScript = false;
-	}
+	const isTypeScript = fs.existsSync(path.join(process.cwd(), "tsconfig.json"));
+	const tagName = hyphaneteComponentName(componentName);
 
 	generateFiles(componentName, tagName, library, packageName, isTypeScript);
 };

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

@@ -33,7 +33,7 @@ const metadata = {
  * For the <code>${tagName}</code>
  * <h3>ES6 Module Import</h3>
  *
- * <code>import ${packageName}/dist/${componentName}.js";</code>
+ * <code>import "${packageName}/dist/${componentName}.js";</code>
  *
  * @constructor
  * @author SAP SE
@@ -62,10 +62,6 @@ class ${componentName} extends UI5Element {
 	static get dependencies() {
 		return [];
 	}
-
-	static async onDefine() {
-
-	}
 }
 
 ${componentName}.define();

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

@@ -22,13 +22,10 @@ import ${componentName}Css from "./generated/themes/${componentName}.css.js";
  * For the <code>${tagName}</code>
  * <h3>ES6 Module Import</h3>
  *
- * <code>import ${packageName}/dist/${componentName}.js";</code>
+ * <code>import "${packageName}/dist/${componentName}.js";</code>
  *
  * @constructor
- * @author SAP SE
- * @alias sap.ui.webc.${library}.${componentName}
- * @extends sap.ui.webc.base.UI5Element
- * @tagname ${tagName}
+ * @extends UI5Element
  * @public
  */
 @customElement({
@@ -43,7 +40,6 @@ import ${componentName}Css from "./generated/themes/${componentName}.css.js";
  * Example custom event.
  * Please keep in mind that all public events should be documented in the API Reference as shown below.
  *
- * @event sap.ui.webc.${library}.${componentName}#interact
  * @public
  */
 @event("interact", { detail: { /* event payload ( optional ) */ } })
@@ -51,9 +47,7 @@ class ${componentName} extends UI5Element {
 	/**
 	 * Defines the value of the component.
 	 *
-	 * @type {string}
-	 * @name sap.ui.webc.${library}.${componentName}.prototype.value
-	 * @defaultvalue ""
+	 * @default ""
 	 * @public
 	 */
 	@property()
@@ -62,17 +56,10 @@ class ${componentName} extends UI5Element {
 	/**
 	 * Defines the text of the component.
 	 *
-	 * @type {Node[]}
-	 * @name sap.ui.webc.${library}.${componentName}.prototype.default
-	 * @slot
 	 * @public
 	 */
 	@slot({ type: Node, "default": true })
 	text!: Array<Node>;
-
-	static async onDefine() {
-
-	}
 }
 
 ${componentName}.define();

package/lib/css-processors/css-processor-component-styles.mjs

@@ -0,0 +1,47 @@
+import { globby } from "globby";
+import * as esbuild from 'esbuild'
+import * as fs from "fs";
+import * as path from "path";
+import { writeFile, mkdir } from "fs/promises";
+import scopeVariables from "./scope-variables.mjs";
+
+const packageJSON = JSON.parse(fs.readFileSync("./package.json"))
+const inputFiles = await globby("src/styles/*.module.css");
+const restArgs = process.argv.slice(2);
+
+let componentStylesPlugin = {
+    name: 'component-styles',
+    setup(build) {
+        build.initialOptions.write = false;
+
+        build.onEnd(result => {
+            result.outputFiles.forEach(async f => {
+                // scoping
+                const newText = scopeVariables(f.text, packageJSON);
+                await mkdir(path.dirname(f.path), {recursive: true});
+                writeFile(f.path, newText);
+                writeFile(f.path.replace(".module.css", ".css"), newText);
+            });
+        })
+    },
+}
+
+const config = {
+    entryPoints: inputFiles,
+    outdir: 'dist',
+    outbase: 'src',
+    loader: {
+        ".module.css": "global-css"
+    },
+    plugins: [
+        componentStylesPlugin,
+    ]
+};
+
+if (restArgs.includes("-w")) {
+    let ctx = await esbuild.context(config);
+    await ctx.watch()
+    console.log('watching...')
+} else {
+    await esbuild.build(config);
+}

package/lib/css-processors/css-processor-components.mjs

@@ -0,0 +1,77 @@
+import { globby } from "globby";
+import * as esbuild from 'esbuild'
+import * as fs from "fs";
+import * as path from "path";
+import { writeFile, mkdir } from "fs/promises";
+import chokidar from "chokidar";
+import scopeVariables from "./scope-variables.mjs";
+import { writeFileIfChanged, getFileContent } from "./shared.mjs";
+
+const tsMode = process.env.UI5_TS === "true";
+const extension = tsMode ? ".css.ts" : ".css.js";
+
+const packageJSON = JSON.parse(fs.readFileSync("./package.json"))
+const inputFilesGlob = "src/themes/*.css";
+const restArgs = process.argv.slice(2);
+
+let customPlugin = {
+    name: 'ui5-tools',
+    setup(build) {
+        build.initialOptions.write = false;
+
+        build.onEnd(result => {
+            result.outputFiles.forEach(async f => {
+                // scoping
+                const newText = scopeVariables(f.text, packageJSON);
+                await mkdir(path.dirname(f.path), {recursive: true});
+                writeFile(f.path, newText);
+
+                // JS/TS
+                const jsPath = f.path.replace(/dist[\/\\]css/, "src/generated/").replace(".css", extension);
+                const jsContent = getFileContent(tsMode, jsPath, packageJSON.name, "\`" + newText + "\`", true);
+                writeFileIfChanged(jsPath, jsContent);
+            });
+        })
+    },
+}
+
+const getConfig = async () => {
+    const config = {
+        entryPoints: await globby(inputFilesGlob),
+        bundle: true,
+        minify: true,
+        outdir: 'dist/css',
+        outbase: 'src',
+        plugins: [
+            customPlugin,
+        ]
+    };
+    return config;
+}
+
+if (restArgs.includes("-w")) {
+    let ready;
+    let config = await getConfig();
+    let ctx = await esbuild.context(config);
+    await ctx.watch()
+    console.log('watching...')
+
+    // when new component css files are added, they do not trigger a build as no one directly imports them
+    // restart the watch mode with the new entry points if a css file is added.
+    const watcher = chokidar.watch(inputFilesGlob);
+    watcher.on("ready", () => {
+        ready = true; // Initial scan is over -> waiting for new files
+    });
+    watcher.on("add", async path => {
+        if (ready) {
+            // new file
+            ctx.dispose();
+            config = await getConfig();
+            ctx = await esbuild.context(config);
+            ctx.watch();
+        }
+    });
+} else {
+    const config = await getConfig();
+    const result = await esbuild.build(config);
+}

package/lib/css-processors/css-processor-themes.mjs

@@ -0,0 +1,79 @@
+import { globby } from "globby";
+import * as esbuild from 'esbuild'
+import * as fs from "fs";
+import * as path from "path";
+import { writeFile, mkdir } from "fs/promises";
+import postcss from "postcss";
+import combineDuplicatedSelectors from "../postcss-combine-duplicated-selectors/index.js"
+import { writeFileIfChanged, stripThemingBaseContent, getFileContent } from "./shared.mjs";
+import scopeVariables from "./scope-variables.mjs";
+
+const tsMode = process.env.UI5_TS === "true";
+const extension = tsMode ? ".css.ts" : ".css.js";
+
+const packageJSON = JSON.parse(fs.readFileSync("./package.json"))
+
+let inputFiles = await globby("src/**/parameters-bundle.css");
+const restArgs = process.argv.slice(2);
+
+const removeDuplicateSelectors = async (text) => {
+    const result = await postcss(combineDuplicatedSelectors).process(text);
+    return result.css;
+}
+
+let scopingPlugin = {
+    name: 'scoping',
+    setup(build) {
+        build.initialOptions.write = false;
+
+        build.onEnd(result => {
+            result.outputFiles.forEach(async f => {
+                // remove duplicate selectors
+                let newText = await removeDuplicateSelectors(f.text);
+
+                // strip unnecessary theming-base-content
+                newText = stripThemingBaseContent(newText);
+
+                // scoping
+                newText = scopeVariables(newText, packageJSON, f.path);
+                await mkdir(path.dirname(f.path), {recursive: true});
+                writeFile(f.path, newText);
+
+                // JSON
+                const jsonPath = f.path.replace(/dist[\/\\]css/, "dist/generated/assets").replace(".css", ".css.json");
+                await mkdir(path.dirname(jsonPath), {recursive: true});
+                const data = {
+                    packageName: packageJSON.name,
+                    fileName: jsonPath.substr(jsonPath.lastIndexOf("themes")),
+                    content: newText,
+                };
+                writeFileIfChanged(jsonPath, JSON.stringify({_: data}));
+
+                // JS/TS
+                const jsPath = f.path.replace(/dist[\/\\]css/, "src/generated/").replace(".css", extension);
+                const jsContent = getFileContent(tsMode, jsPath, packageJSON.name, "\`" + newText + "\`");
+                writeFileIfChanged(jsPath, jsContent);
+            });
+        })
+    },
+}
+
+const config = {
+    entryPoints: inputFiles,
+    bundle: true,
+    minify: true,
+    outdir: 'dist/css',
+    outbase: 'src',
+    plugins: [
+        scopingPlugin,
+    ],
+    external: ["*.ttf", "*.woff", "*.woff2"],
+};
+
+if (restArgs.includes("-w")) {
+    let ctx = await esbuild.context(config);
+    await ctx.watch()
+    console.log('watching...')
+} else {
+    const result = await esbuild.build(config);
+}

package/lib/css-processors/scope-variables.mjs

@@ -0,0 +1,49 @@
+import * as path from "path";
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Tries to detect an override for a package
+ * @param {*} filePath For example: /my_project/src/themes/overrides/@ui5/webcomponents/my_custom_theme/parameters-bundle.css
+ * @returns
+ */
+const getOverrideVersion = filePath => {
+    if (!filePath) {
+        return;
+    }
+
+	if (!filePath.includes(`overrides${path.sep}`)) {
+		return; // The "overrides/" directory is the marker
+	}
+	const override = filePath.split(`overrides${path.sep}`)[1]; // For example, this will be: @ui5/webcomponents/my_custom_theme/parameters-bundle.css
+	if (!override) {
+		return; // There must be other directories after overrides/, the path can't end with it
+	}
+	const parts = override.split(path.sep);
+	if (parts.length < 3) {
+		return; // There must be at least a directory for the theme that is being overridden (my_custom_theme) and the name of the CSS file after the name of the package that is overridden
+	}
+	const packageName = parts.slice(0, -2).join(path.sep); // After the last 2 parts are removed (my_custom_theme and parameters-bundle.css from the example), the rest is the package
+
+	let overrideVersion;
+	try {
+		overrideVersion = require(`${packageName}${path.sep}package.json`).version;
+	} catch (e) {
+		console.log(`Error requiring package ${packageName}: ${e.message}`);
+	}
+
+	return overrideVersion;
+}
+
+const scopeVariables = (cssText, packageJSON, inputFile) => {
+    const escapeVersion = version => "v" + version?.replaceAll(/[^0-9A-Za-z\-_]/g, "-");
+    const versionStr = escapeVersion(getOverrideVersion(inputFile) || packageJSON.version);
+
+    const expr = /(--_?ui5)([^\,\:\)\s]+)/g;
+
+    return cssText.replaceAll(expr, `$1-${versionStr}$2`);
+}
+
+export default scopeVariables;
+

package/lib/{postcss-css-to-esm/index.js → css-processors/shared.mjs}

@@ -1,7 +1,38 @@
-const fs = require('fs');
-const path = require('path');
-const mkdirp = require('mkdirp');
-const assets = require("../../assets-meta.js");
+import { writeFile, readFile, mkdir } from "fs/promises";
+import * as path from "path";
+import assets from "../../assets-meta.js";
+
+const readOldContent = async (fileName) => {
+    // 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 = (await readFile(fileName)).toString();
+    } catch (e) {
+        // file not found
+    }
+    return oldContent;
+}
+
+const writeFileIfChanged = async (fileName, content) => {
+    const oldContent = await readOldContent(fileName);
+    if (content !== oldContent) {
+        if (!oldContent) {
+            await mkdir(path.dirname(fileName), {recursive: true});
+        }
+        return writeFile(fileName, content);
+    }
+}
+
+// strips the unnecessary theming data coming from @sap-theming/theming-base-content and leaves only the css parameters
+const stripThemingBaseContent = 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;
+}
+
 
 const DEFAULT_THEME = assets.themes.default;
 
@@ -42,49 +73,4 @@ const getJSContent = (targetFile, packageName, css, includeDefaultTheme) => {
 	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 || {};
-
-	const packageName = opts.packageName;
-	const includeDefaultTheme = opts.includeDefaultTheme;
-	const toReplace = opts.toReplace;
-
-	return {
-		postcssPlugin: 'postcss-css-to-esm',
-		Once (root) {
-			const tsMode = process.env.UI5_TS === "true";
-
-			let css = root.toString();
-			css = proccessCSS(css);
-
-			const targetFile = root.source.input.from.replace(`/${toReplace}/`, "/src/generated/").replace(`\\${toReplace}\\`, "\\src\\generated\\");
-			mkdirp.sync(path.dirname(targetFile));
-
-			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;
+export { writeFileIfChanged, stripThemingBaseContent, getFileContent}

package/lib/dev-server/custom-hot-update-plugin.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+
+/**
+ * A change is observed on MacOS since 13.5, where the build generates a large amount
+ * of JSON file that spotlight search has to index, as they are considered new files.
+ *
+ * Starting the vitejs dev server reads all of these files and this triggers the indexing.
+ * The indexing has a side effect of changing some file metadata (can be checked with `mdls <path_to_file>`).
+ * This metadata change is changing the ctime of the file, but not the mtime. This can be checked with `stat -x <path_to_file>
+ *
+ * Essentially only metadata is changed, not content. This should not cause a page refresh,
+ * but chokidar reports this change and vite refreshes the page.
+ * The indexing is running with a 10 second interval, so for roughtly 20 minutes vite is refreshing the page every 10 seconds
+ *
+ * This plugin checks if the file causing the refresh is a generated json file (dist/*.json) and if ctime is changed after mtime
+ * In that case, returing an empty array tells vitejs that a custom update will be made by the plugin,
+ * which is in effect ignoring the page refresh.
+ */
+
+const customHotUpdate = async () => {
+	return {
+		name: 'custom-hot-update',
+		handleHotUpdate(ctx) {
+			// custom check for generated json files
+			if (ctx.file.endsWith(".json")) {
+				const stat = fs.statSync(ctx.file);
+
+				// metadata change only
+				if (stat.ctime > stat.mtime) {
+					// uncomment for debugging
+					// console.log("ignoring hot update for:", ctx.file);
+					return [];
+				}
+			}
+		}
+	}
+};
+
+module.exports = customHotUpdate;