@webiny/build-tools 6.0.0 → 6.1.0-beta.1

package/bundling/admin/createRsbuildConfig.js

@@ -33,11 +33,21 @@ export const createRsbuildConfig = ({ cwd }) => {
         },
         tools: {
             postcss: (_, { addPlugins }) => {
-                addPlugins(
+                addPlugins([
+                    createInjectTailwindSourcePlugin(
+                        path.join(paths.projectRootFolder, "extensions")
+                    ),
                     tailwindcss({
                         base: getTailwindBasePath(paths.projectRootFolder)
                     })
-                );
+                ]);
+            },
+            rspack: {
+                watchOptions: {
+                    // Wait for dependency builds to finish before triggering a recompilation.
+                    aggregateTimeout: 500,
+                    ignored: ["**/node_modules/**", "**/.git/**"]
+                }
             }
         },
         server: { port: 3001 },
@@ -104,6 +114,17 @@ const getTailwindBasePath = projectRootFolderPath => {
     return path.join(projectRootFolderPath, "node_modules", "@webiny");
 };
 
+/*
+    Injects an `@source` directive into the Tailwind CSS AST at build time, pointing to the
+    given absolute path. https://tailwindcss.com/docs/functions-and-directives#source-directive
+*/
+const createInjectTailwindSourcePlugin = sourcePath => ({
+    postcssPlugin: "inject-tailwind-source",
+    Once(root) {
+        root.prepend(`@source "${sourcePath}";`);
+    }
+});
+
 const getEnvVars = () => {
     const raw = Object.keys(process.env)
         .filter(key => {

package/bundling/function/createRsbuildConfig.js

@@ -30,7 +30,7 @@ export const createRsbuildConfig = ({ cwd }) => {
         },
         tools: {
             rspack: {
-                externals: [/^@aws-sdk/, /^sharp$/],
+                externals: [/^@aws-sdk/, /^aws-sdk$/, /^sharp$/],
                 plugins: [
                     // This is necessary to enable JSDOM usage in Lambda.
                     // https://rspack.dev/plugins/webpack/ignore-plugin

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/build-tools",
-	"version": "6.0.0",
+	"version": "6.1.0-beta.1",
 	"type": "module",
 	"main": "index.js",
 	"description": "A collection of utilities for Webiny project.",
@@ -15,26 +15,26 @@
 	],
 	"dependencies": {
 		"@babel/core": "7.29.0",
-		"@babel/preset-env": "7.29.0",
+		"@babel/preset-env": "7.29.2",
 		"@babel/preset-react": "7.28.5",
 		"@babel/preset-typescript": "7.28.5",
-		"@babel/runtime": "7.28.6",
-		"@rsbuild/core": "1.7.3",
-		"@rsbuild/plugin-react": "1.4.5",
-		"@rsbuild/plugin-sass": "1.5.0",
-		"@rsbuild/plugin-svgr": "1.3.0",
+		"@babel/runtime": "7.29.2",
+		"@rsbuild/core": "1.7.4",
+		"@rsbuild/plugin-react": "1.4.6",
+		"@rsbuild/plugin-sass": "1.5.1",
+		"@rsbuild/plugin-svgr": "1.3.1",
 		"@rsbuild/plugin-type-check": "1.3.4",
-		"@rspack/core": "1.7.8",
-		"@svgr/webpack": "6.5.1",
-		"@swc/plugin-emotion": "11.5.0",
-		"@tailwindcss/postcss": "4.2.1",
+		"@rspack/core": "1.7.10",
+		"@svgr/webpack": "8.1.0",
+		"@swc/plugin-emotion": "14.7.0",
+		"@tailwindcss/postcss": "4.2.2",
 		"@types/webpack-env": "1.18.8",
-		"chalk": "4.1.2",
-		"chokidar": "4.0.3",
+		"chalk": "5.6.2",
+		"chokidar": "5.0.0",
 		"css-loader": "7.1.4",
-		"eslint": "10.0.3",
+		"eslint": "10.1.0",
 		"fast-glob": "3.3.3",
-		"find-up": "5.0.0",
+		"find-up": "8.0.0",
 		"fs-extra": "11.3.4",
 		"get-yarn-workspaces": "1.0.2",
 		"lodash": "4.17.23",
@@ -42,12 +42,12 @@
 		"process": "0.11.10",
 		"raw-loader": "4.0.2",
 		"react-dom": "18.2.0",
-		"react-refresh": "0.11.0",
+		"react-refresh": "0.18.0",
 		"read-json-sync": "2.0.1",
 		"rimraf": "6.1.3",
-		"sass": "1.97.3",
+		"sass": "1.98.0",
 		"sass-loader": "16.0.7",
-		"style-loader": "3.3.4",
+		"style-loader": "4.0.0",
 		"ts-morph": "27.0.2",
 		"tsx": "4.21.0",
 		"typescript": "5.9.3",
@@ -89,5 +89,5 @@
 		"access": "public",
 		"directory": "."
 	},
-	"gitHead": "9c6892640a45679ff521e25cd6587dff57393a2e"
+	"gitHead": "3c1293ba17a14f239fb1cbf5d80cd66846849309"
 }

package/packages/buildPackage/tsAliasReplacer.js

@@ -1,25 +1,38 @@
-import { dirname, relative } from "path";
+import { dirname, join, relative, resolve } from "node:path";
 import fg from "fast-glob";
-import fs from "fs";
+import fs from "node:fs";
 
+/**
+ *
+ * @param distDir {String}
+ * @param cwd {String}
+ * @param debug {Boolean}
+ * @returns {Promise<void>}
+ */
 export const replaceTscAliases = async ({ distDir, cwd, debug = false }) => {
     const dtsFiles = await fg("**/*.d.ts", {
         cwd: distDir,
         absolute: true
     });
 
+    // Build a map of absolute src paths → package names, by scanning sibling packages.
+    // This is used to rewrite cross-package src paths (e.g. "../../api/src") back to
+    // proper package names (e.g. "@webiny/api") in generated .d.ts files.
+    const srcToPackageName = buildSrcToPackageNameMap(cwd);
+
     for (const dtsFile of dtsFiles) {
-        let content = fs.readFileSync(dtsFile, "utf8");
+        let content = fs.readFileSync(dtsFile, "utf8").toString();
         let modified = false;
 
         // Replace all imports/exports with ~/ alias
         content = content.replace(
             /(from\s+["'])~\/([^"']+)(["'])/g,
-            (match, prefix, importPath, suffix) => {
+            (_, prefix, importPath, suffix) => {
                 modified = true;
                 // Calculate relative path from current file to dist root
-                const fileDir = dirname(dtsFile);
-                const relativePath = relative(fileDir, distDir);
+                const fileDir = dirname(dtsFile).replace(/\\/g, "/");
+                const normalizedDistDir = distDir.replace(/\\/g, "/");
+                const relativePath = relative(fileDir, normalizedDistDir).replace(/\\/g, "/");
                 const finalPath = relativePath
                     ? `${relativePath}/${importPath}`
                     : `./${importPath}`;
@@ -29,11 +42,84 @@ export const replaceTscAliases = async ({ distDir, cwd, debug = false }) => {
             }
         );
 
+        // Replace cross-package src paths (e.g. "../../api/src/types") with proper package
+        // names (e.g. "@webiny/api/types"). TypeScript inlines these relative paths when
+        // project references are used and dependencies have paths pointing to src/.
+        if (srcToPackageName.size > 0) {
+            content = content.replace(
+                /["'](\.\.[^"']*\/src(?:\/[^"']*)?)['"]/g,
+                (match, relPath) => {
+                    const quote = match[0];
+                    const absPath = resolve(dirname(dtsFile), relPath);
+                    const packageName = resolveToPackageName(absPath, srcToPackageName);
+                    if (packageName) {
+                        modified = true;
+                        return `${quote}${packageName}${quote}`;
+                    }
+                    return match;
+                }
+            );
+        }
+
         if (modified) {
             fs.writeFileSync(dtsFile, content, "utf8");
             if (debug) {
-                console.log(`Resolved ~ aliases in: ${relative(cwd, dtsFile)}`);
+                console.log(`Resolved aliases in: ${relative(cwd, dtsFile)}`);
             }
         }
     }
 };
+
+/**
+ * Scans sibling packages to build a map of absolute src directory paths → package names.
+ * @param {string} cwd - The current package directory.
+ * @returns {Map<string, string>}
+ */
+function buildSrcToPackageNameMap(cwd) {
+    const map = new Map();
+    // Go up to the packages/ directory (cwd is packages/xxx, parent is packages/)
+    const packagesDir = resolve(cwd, "..");
+    if (!fs.existsSync(packagesDir)) {
+        return map;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(packagesDir);
+    } catch {
+        return map;
+    }
+    for (const entry of entries) {
+        const pkgDir = join(packagesDir, entry);
+        const pkgJsonPath = join(pkgDir, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+            continue;
+        }
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+            if (pkgJson.name) {
+                const srcDir = join(pkgDir, "src");
+                map.set(srcDir, pkgJson.name);
+            }
+        } catch {
+            // ignore
+        }
+    }
+    return map;
+}
+
+/**
+ * Given an absolute path that points into a package's src directory, returns the
+ * corresponding package name + sub-path (e.g. "@webiny/api/types").
+ * @param {string} absPath - Absolute path resolved from the relative import.
+ * @param {Map<string, string>} srcToPackageName
+ * @returns {string|null}
+ */
+function resolveToPackageName(absPath, srcToPackageName) {
+    for (const [srcDir, packageName] of srcToPackageName) {
+        if (absPath === srcDir || absPath.startsWith(srcDir + "/")) {
+            const subPath = absPath.slice(srcDir.length).replace(/^\//, "");
+            return subPath ? `${packageName}/${subPath}` : packageName;
+        }
+    }
+    return null;
+}

package/packages/buildPackage/tsCompile.js

@@ -4,7 +4,10 @@ import merge from "lodash/merge.js";
 import { replaceTscAliases } from "./tsAliasReplacer.js";
 
 export const tsCompile = async ({ cwd = "", overrides, debug }) => {
-    const tsConfigPath = join(cwd, "tsconfig.build.json");
+    // Normalize path separators to forward slashes for consistent behavior on Windows.
+    const normalizedCwd = cwd.replace(/\\/g, "/");
+
+    const tsConfigPath = join(normalizedCwd, "tsconfig.build.json");
 
     let { config: readTsConfig } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
 
@@ -20,11 +23,10 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
             console.log(readTsConfig);
         }
     }
-    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, cwd);
+    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, normalizedCwd);
 
     const { projectReferences, options, fileNames, errors } = parsedJsonConfigFile;
 
-    // Exclude .d.ts files from TypeScript compilation
     const filteredFileNames = fileNames.filter(fileName => !fileName.endsWith(".d.ts"));
 
     const program = ts.createProgram({
@@ -36,10 +38,12 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
 
     const { diagnostics, emitSkipped } = program.emit(
         undefined, // targetSourceFile
-        (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
-            // Only emit files within the current package directory
-            const relativePath = fileName.replace(cwd, "");
-            if (fileName.startsWith(cwd) && !relativePath.includes("../")) {
+        (fileName, data, writeByteOrderMark) => {
+            // Only emit files within the current package directory.
+            // Normalize path separators to handle Windows backslashes vs forward slashes.
+            const normalizedFileName = fileName.replace(/\\/g, "/");
+            const relativePath = normalizedFileName.replace(normalizedCwd, "");
+            if (normalizedFileName.startsWith(normalizedCwd) && !relativePath.includes("../")) {
                 ts.sys.writeFile(fileName, data, writeByteOrderMark);
             }
         }
@@ -50,7 +54,7 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
     if (allDiagnostics.length) {
         const formatHost = {
             getCanonicalFileName: path => path,
-            getCurrentDirectory: () => cwd,
+            getCurrentDirectory: () => normalizedCwd,
             getNewLine: () => ts.sys.newLine
         };
         const message = ts.formatDiagnostics(allDiagnostics, formatHost);
@@ -64,6 +68,6 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
     }
 
     // Resolve ~ path aliases in .d.ts files
-    const distDir = options.outDir || join(cwd, "dist");
-    await replaceTscAliases({ distDir, cwd, debug });
+    const distDir = options.outDir || join(normalizedCwd, "dist");
+    await replaceTscAliases({ distDir, cwd: normalizedCwd, debug });
 };

package/packages/buildPackage.js

@@ -1,5 +1,6 @@
 import * as rimraf from "rimraf";
 import { join } from "path";
+import fs from "node:fs";
 import { babelCompile } from "./buildPackage/babelCompile.js";
 import { tsCompile } from "./buildPackage/tsCompile.js";
 import { copyToDist } from "./buildPackage/copyToDist.js";
@@ -12,8 +13,7 @@ export default async options => {
         options.cwd = "";
     }
     const { cwd = "" } = options;
-    options.logs !== false && console.log("Deleting existing build files...");
-    rimraf.sync(join(cwd, "./dist"));
+
     rimraf.sync(join(cwd, "*.tsbuildinfo"), { glob: true });
 
     options.logs !== false && console.log("Building...");
@@ -26,6 +26,16 @@ export default async options => {
     // Validate ESM imports before compiling
     await validateEsmImports({ cwd, logs: options.logs });
 
+    // Clear dist/ contents without removing the directory itself.
+    // node_modules/@webiny/<pkg> symlinks directly to dist/, so deleting
+    // the directory would leave a dangling symlink and break Rspack resolution.
+    const distDir = join(cwd, "dist");
+    if (fs.existsSync(distDir)) {
+        for (const entry of fs.readdirSync(distDir)) {
+            fs.rmSync(join(distDir, entry), { recursive: true, force: true });
+        }
+    }
+
     await babelCompile(options);
     await tsCompile(options);
 

package/utils/PackageJson.backup.ts

@@ -1,7 +1,7 @@
 // We'll use this class once the package is converted to TS!
 
 import readJson from "read-json-sync";
-import findUp from "find-up";
+import { findUp } from "find-up";
 
 export class PackageJson {
     private readonly filePath: string;

package/utils/PackageJson.js

@@ -1,5 +1,5 @@
 import readJson from "read-json-sync";
-import findUp from "find-up";
+import { findUp } from "find-up";
 
 export class PackageJson {
     filePath;