@webiny/build-tools 0.0.0-unstable.0d717d18dd

package/package.json

@@ -0,0 +1,82 @@
+{
+	"name": "@webiny/build-tools",
+	"version": "0.0.0-unstable.0d717d18dd",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "A collection of utilities for Webiny project.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"author": "Pavel Denisjuk <pavel@webiny.com>",
+	"contributors": [
+		"Sven Al Hamad <sven@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"dependencies": {
+		"@rsbuild/core": "2.1.9",
+		"@rsbuild/plugin-react": "2.1.0",
+		"@rsbuild/plugin-sass": "2.0.1",
+		"@rsbuild/plugin-svgr": "2.0.5",
+		"@rsbuild/plugin-type-check": "1.6.0",
+		"@rsdoctor/rspack-plugin": "1.6.1",
+		"@rslib/core": "0.23.2",
+		"@rspack/core": "2.1.7",
+		"@swc/plugin-emotion": "14.15.0",
+		"@tailwindcss/postcss": "4.3.3",
+		"@webiny/stdlib": "0.0.15",
+		"chalk": "6.0.0",
+		"css-loader": "7.1.4",
+		"fast-glob": "3.3.3",
+		"find-up": "8.0.0",
+		"fs-extra": "11.4.0",
+		"load-json-file": "7.0.1",
+		"lodash": "4.18.1",
+		"postcss-loader": "8.2.1",
+		"raw-loader": "4.0.2",
+		"react-dom": "18.3.1",
+		"react-refresh": "0.18.0",
+		"rimraf": "6.1.3",
+		"sass": "1.102.0",
+		"sass-loader": "17.0.0",
+		"strip-json-comments": "5.0.3",
+		"style-loader": "4.0.0",
+		"ts-morph": "28.0.0",
+		"tsx": "4.23.1",
+		"typescript": "7.0.2",
+		"url-loader": "4.1.1",
+		"utf-8-validate": "6.0.6"
+	},
+	"license": "MIT",
+	"adio": {
+		"ignore": {
+			"src": [
+				"@webiny/admin-ui",
+				"@webiny/app",
+				"!!raw-loader!"
+			],
+			"dependencies": [
+				"@swc/plugin-emotion",
+				"postcss-loader",
+				"raw-loader",
+				"react-refresh",
+				"style-loader",
+				"typescript",
+				"sass-loader",
+				"sass",
+				"bufferutil",
+				"utf-8-validate",
+				"css-loader",
+				"url-loader",
+				"@rsdoctor/rspack-plugin"
+			]
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"gitHead": "b8aec8a1be3f25c3b428b357fe1e352c7cbff9ae"
+}

package/packages/buildPackage/copyToDist.js

@@ -0,0 +1,11 @@
+import fs from "fs";
+import { join } from "path";
+
+export const copyToDist = (path, { cwd, logs, outputDir }) => {
+    const from = join(cwd, path);
+    const to = join(outputDir || join(cwd, "dist"), path);
+    if (fs.existsSync(from)) {
+        fs.copyFileSync(from, to);
+        logs !== false && console.log(`Copied ${path}.`);
+    }
+};

package/packages/buildPackage/rslibCompile.js

@@ -0,0 +1,65 @@
+import path from "path";
+import fs from "fs";
+import { dirname } from "path";
+import glob from "fast-glob";
+
+const COMPILE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+const SKIP_EXTENSIONS = [".d.ts"];
+
+export const rslibCompile = async ({ cwd, outputDir }) => {
+    const distRoot = outputDir || path.join(cwd, "dist");
+
+    // Copy non-compilable files (assets, json, graphql, etc.) as-is.
+    const pattern = path.join(cwd, "src/**/*.*").replace(/\\/g, "/");
+    const allFiles = glob.sync(pattern, { onlyFiles: true, dot: true });
+
+    for (const file of allFiles) {
+        const shouldCompile = COMPILE_EXTENSIONS.some(ext => file.endsWith(ext));
+        const shouldSkip = SKIP_EXTENSIONS.some(ext => file.endsWith(ext));
+
+        if (!shouldCompile || shouldSkip) {
+            const destPath = file.replace(path.join(cwd, "src"), distRoot);
+            fs.mkdirSync(dirname(destPath), { recursive: true });
+            fs.copyFileSync(file, destPath);
+        }
+    }
+
+    // Must be a dynamic import. @rslib/core statically loads rspack's native
+    // binding. Workers that also run createBuildAdmin load a different rspack
+    // version via rsbuild, so two native binaries end up in the same process
+    // and cause a SIGSEGV. Deferring the import keeps each rspack isolated to
+    // the workers that actually need it.
+    const [{ createRslib }, { pluginSvgr }] = await Promise.all([
+        import("@rslib/core"),
+        import("@rsbuild/plugin-svgr")
+    ]);
+
+    const rslib = await createRslib({
+        cwd,
+        config: {
+            lib: [{ format: "esm", bundle: false }],
+            source: {
+                // SVGs included so rslib runs them through pluginSvgr and emits
+                // a .js React-component module alongside the copied .svg asset.
+                entry: ["./src/**/*.{ts,tsx,js,jsx,svg}"],
+                alias: { "~": "./src" }
+            },
+            output: {
+                target: "web",
+                distPath: { root: path.relative(cwd, distRoot) || "." },
+                cleanDistPath: false,
+                sourceMap: { js: "source-map" },
+                // mixedImport emits each SVG as a static asset for the default URL
+                // export. Without a hash, two files named the same (e.g. fullscreen.svg
+                // in different dirs) collide at static/svg/fullscreen.svg.
+                // loader-utils [ext] has no leading dot, so "[name].[hash][ext]" produces
+                // "foo.hashsvg". Use an explicit ".svg" suffix instead.
+                filename: { svg: "[name].[contenthash:8].svg" }
+            },
+            plugins: [pluginSvgr({ mixedImport: true, svgrOptions: { exportType: "named" } })]
+        }
+    });
+
+    const { close } = await rslib.build();
+    await close();
+};

package/packages/buildPackage/tsAliasReplacer.js

@@ -0,0 +1,125 @@
+import { dirname, join, relative, resolve } from "node:path";
+import fg from "fast-glob";
+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").toString();
+        let modified = false;
+
+        // Replace all imports/exports with ~/ alias
+        content = content.replace(
+            /(from\s+["'])~\/([^"']+)(["'])/g,
+            (_, prefix, importPath, suffix) => {
+                modified = true;
+                // Calculate relative path from current file to dist root
+                const fileDir = dirname(dtsFile).replace(/\\/g, "/");
+                const normalizedDistDir = distDir.replace(/\\/g, "/");
+                const relativePath = relative(fileDir, normalizedDistDir).replace(/\\/g, "/");
+                const finalPath = relativePath
+                    ? `${relativePath}/${importPath}`
+                    : `./${importPath}`;
+                // Normalize to always start with ./
+                const normalized = finalPath.startsWith(".") ? finalPath : `./${finalPath}`;
+                return `${prefix}${normalized}${suffix}`;
+            }
+        );
+
+        // 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)}`);
+            }
+        }
+    }
+};
+
+/**
+ * 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

@@ -0,0 +1,80 @@
+import { join, resolve } from "path";
+import fs from "node:fs";
+import merge from "lodash/merge.js";
+import { replaceTscAliases } from "./tsAliasReplacer.js";
+import { getTscBinaryPath } from "./typescript/getTscBinaryPath.js";
+import { readTsConfig } from "./typescript/readTsConfig.js";
+import { runTsc } from "./typescript/runTsc.js";
+import { writeTempTsConfig } from "./typescript/writeTempTsConfig.js";
+
+export const tsCompile = async ({ cwd = "", overrides, debug, outputDir, checkOnly = false }) => {
+    const normalizedCwd = cwd || process.cwd();
+    const tscPath = getTscBinaryPath();
+
+    const originalConfigPath = join(normalizedCwd, "tsconfig.build.json");
+    let tsConfigPath = originalConfigPath;
+    let tempConfigPath = null;
+    let resolvedOutDir = null;
+
+    const hasOverrides = overrides?.tsConfig || outputDir;
+
+    if (hasOverrides) {
+        let config = readTsConfig(originalConfigPath);
+
+        if (overrides?.tsConfig) {
+            if (typeof overrides.tsConfig === "function") {
+                config = overrides.tsConfig(config);
+            } else {
+                merge(config, overrides.tsConfig);
+            }
+
+            if (debug) {
+                console.log(`"tsconfig.build.json" overridden. New config:`);
+                console.log(config);
+            }
+        }
+
+        if (outputDir) {
+            config.compilerOptions = config.compilerOptions || {};
+            config.compilerOptions.outDir = outputDir;
+            config.compilerOptions.declarationDir = outputDir;
+        }
+
+        resolvedOutDir = config.compilerOptions?.outDir;
+        tempConfigPath = writeTempTsConfig(normalizedCwd, config);
+        tsConfigPath = tempConfigPath;
+    }
+
+    try {
+        const args = ["-p", tsConfigPath];
+        args.push("--tsBuildInfoFile", join(normalizedCwd, "tsconfig.build.tsbuildinfo"));
+
+        if (checkOnly) {
+            args.push("--noEmit");
+        }
+
+        runTsc(tscPath, args, normalizedCwd);
+    } finally {
+        if (tempConfigPath) {
+            fs.rmSync(tempConfigPath, { force: true });
+        }
+    }
+
+    if (!checkOnly) {
+        const distDir =
+            outputDir || resolveDistDir(normalizedCwd, originalConfigPath, resolvedOutDir);
+        await replaceTscAliases({ distDir, cwd: normalizedCwd, debug });
+    }
+};
+
+function resolveDistDir(cwd, configPath, overriddenOutDir) {
+    if (overriddenOutDir) {
+        return resolve(cwd, overriddenOutDir);
+    }
+    const config = readTsConfig(configPath);
+    const outDir = config.compilerOptions?.outDir;
+    if (outDir) {
+        return resolve(cwd, outDir);
+    }
+    return join(cwd, "dist");
+}

package/packages/buildPackage/typescript/getTscBinaryPath.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import fs from "node:fs";
+
+let cachedPath = null;
+
+export function getTscBinaryPath() {
+    if (cachedPath) {
+        return cachedPath;
+    }
+
+    const require = createRequire(import.meta.url);
+    const tsPackageJsonPath = require.resolve("typescript/package.json");
+    const tsDir = dirname(tsPackageJsonPath);
+
+    const platformPackage = "@typescript/typescript-" + process.platform + "-" + process.arch;
+
+    let platformPkgPath;
+    try {
+        const platformRequire = createRequire(join(tsDir, "package.json"));
+        platformPkgPath = platformRequire.resolve(platformPackage + "/package.json");
+    } catch {
+        throw new Error(
+            "Unable to resolve " +
+                platformPackage +
+                ". " +
+                "Either your platform is unsupported, or you are missing the package on disk."
+        );
+    }
+
+    const libDir = join(dirname(platformPkgPath), "lib");
+
+    let exe = join(libDir, "tsc");
+    if (process.platform === "win32") {
+        exe += ".exe";
+        if (exe.length >= 248) {
+            exe = "\\\\?\\" + exe;
+        }
+    }
+
+    if (!fs.existsSync(exe)) {
+        throw new Error("TypeScript native binary not found: " + exe);
+    }
+
+    cachedPath = exe;
+    return cachedPath;
+}

package/packages/buildPackage/typescript/readTsConfig.js

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+import stripJsonComments from "strip-json-comments";
+
+export function readTsConfig(configPath) {
+    const content = fs.readFileSync(configPath, "utf8");
+    const stripped = stripJsonComments(content, { trailingCommas: true });
+    return JSON.parse(stripped);
+}

package/packages/buildPackage/typescript/runTsc.js

@@ -0,0 +1,15 @@
+import { execFileSync } from "node:child_process";
+
+export function runTsc(tscPath, args, cwd) {
+    try {
+        execFileSync(tscPath, args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024
+        });
+    } catch (error) {
+        const output = [error.stdout, error.stderr].filter(Boolean).join("\n").trim();
+        throw { message: output || error.message || "TypeScript compilation failed." };
+    }
+}

package/packages/buildPackage/typescript/writeTempTsConfig.js

@@ -0,0 +1,10 @@
+import { join } from "node:path";
+import fs from "node:fs";
+import { randomBytes } from "node:crypto";
+
+export function writeTempTsConfig(cwd, config) {
+    const suffix = randomBytes(4).toString("hex");
+    const tempPath = join(cwd, `tsconfig.build.tmp-${suffix}.json`);
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2), "utf8");
+    return tempPath;
+}

package/packages/buildPackage/validateEsmImports.js

@@ -0,0 +1,91 @@
+import fs from "fs";
+import { join } from "path";
+import glob from "fast-glob";
+import { Project, SyntaxKind } from "ts-morph";
+import chalk from "chalk";
+
+export const validateEsmImports = async ({ cwd }) => {
+    console.log("Validating ESM imports...");
+
+    const pattern = join(cwd, "src/**/*.{js,ts,tsx}").replace(/\\/g, "/");
+    const files = glob.sync(pattern, {
+        absolute: true,
+        onlyFiles: true
+    });
+
+    const errors = [];
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        skipFileDependencyResolution: true
+    });
+
+    for (const filePath of files) {
+        const content = await fs.promises.readFile(filePath, "utf8");
+        const sourceFile = project.createSourceFile(filePath, content, { overwrite: true });
+
+        // Get all import declarations: import { x } from 'y'
+        const importDeclarations = sourceFile.getImportDeclarations();
+        for (const importDecl of importDeclarations) {
+            const spec = importDecl.getModuleSpecifierValue();
+            await validateImportSpec(spec, filePath, errors);
+        }
+
+        // Get all export declarations: export { x } from 'y'
+        const exportDeclarations = sourceFile.getExportDeclarations();
+        for (const exportDecl of exportDeclarations) {
+            const moduleSpecifier = exportDecl.getModuleSpecifier();
+            if (moduleSpecifier) {
+                const spec = moduleSpecifier.getLiteralValue();
+                await validateImportSpec(spec, filePath, errors);
+            }
+        }
+
+        // Get all dynamic imports: import('y')
+        const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const callExpr of callExpressions) {
+            const expression = callExpr.getExpression();
+            if (expression.getKind() === SyntaxKind.ImportKeyword) {
+                const args = callExpr.getArguments();
+                if (args.length > 0 && args[0].getKind() === SyntaxKind.StringLiteral) {
+                    const spec = args[0].getLiteralValue();
+                    await validateImportSpec(spec, filePath, errors);
+                }
+            }
+        }
+    }
+
+    if (errors.length > 0) {
+        const invalidFiles = [...new Set(errors.map(e => e.file))];
+        const errorMessage = [
+            chalk.red("ESM import validation failed."),
+            `Found ${errors.length} invalid import(s) in ${invalidFiles.length} file(s):`,
+            "",
+            ...errors.map(e => {
+                const relativePath = e.file.replace(cwd, "").replace(/^[\/\\]/, "");
+                return `  ${chalk.red("-")} "${chalk.red(e.spec)}" in "${chalk.red(relativePath)}"`;
+            })
+        ].join("\n");
+        throw new Error(errorMessage);
+    } else {
+        console.log("All ESM imports are valid.");
+    }
+};
+
+async function validateImportSpec(spec, file, errors) {
+    if (spec.startsWith("~") || spec.startsWith("./") || spec.startsWith("../")) {
+        // Extract the file extension from the import path
+        const lastDotIndex = spec.lastIndexOf(".");
+        const lastSlashIndex = Math.max(spec.lastIndexOf("/"), spec.lastIndexOf("\\"));
+        const hasExtension = lastDotIndex > lastSlashIndex;
+
+        // If there's no extension, it should have .js
+        if (!hasExtension) {
+            const relativePath = file.replace(process.cwd(), "").replace(/^[\/\\]/, "");
+            const errorMsg = chalk.red(
+                `- Missing .js extension in import "${spec}" in ${relativePath}`
+            );
+            console.error(errorMsg);
+            errors.push({ file, spec, reason: "missing extension" });
+        }
+    }
+}

package/packages/buildPackage.js

@@ -0,0 +1,93 @@
+import * as rimraf from "rimraf";
+import { join } from "path";
+import fs from "node:fs";
+import { rslibCompile } from "./buildPackage/rslibCompile.js";
+import { tsCompile } from "./buildPackage/tsCompile.js";
+import { copyToDist } from "./buildPackage/copyToDist.js";
+import { validateEsmImports } from "./buildPackage/validateEsmImports.js";
+
+export default async options => {
+    const start = new Date();
+
+    if (!options.cwd) {
+        options.cwd = "";
+    }
+    const { cwd = "" } = options;
+
+    rimraf.sync(join(cwd, "*.tsbuildinfo"), { glob: true });
+
+    options.logs !== false && console.log("Building...");
+
+    // Make sure `overrides` is an object.
+    if (options.overrides && typeof options.overrides === "string") {
+        options.overrides = JSON.parse(options.overrides);
+    }
+
+    // Validate ESM imports before compiling
+    await validateEsmImports({ cwd, logs: options.logs });
+
+    const distDir = join(cwd, "dist");
+
+    if (options.safeReplace) {
+        await buildWithSafeReplace(options, distDir);
+    } else {
+        await buildDirect(options, distDir);
+    }
+
+    const duration = (new Date() - start) / 1000;
+    options.logs !== false && console.log(`Done! Build finished in ${duration + "s"}.`);
+
+    return { duration };
+};
+
+async function buildDirect(options, distDir) {
+    // 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.
+    if (fs.existsSync(distDir)) {
+        for (const entry of fs.readdirSync(distDir)) {
+            fs.rmSync(join(distDir, entry), { recursive: true, force: true });
+        }
+    }
+
+    await rslibCompile(options);
+    await tsCompile(options);
+
+    options.logs !== false && console.log("Copying meta files...");
+    copyToDist("package.json", options);
+    copyToDist("LICENSE", options);
+}
+
+async function buildWithSafeReplace(options, distDir) {
+    const stagingDir = distDir + "._build";
+
+    // Clean up any leftover staging dir from a previous failed build.
+    if (fs.existsSync(stagingDir)) {
+        fs.rmSync(stagingDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(stagingDir, { recursive: true });
+
+    const stagingOptions = { ...options, outputDir: stagingDir };
+
+    await rslibCompile(stagingOptions);
+    await tsCompile(stagingOptions);
+
+    stagingOptions.logs !== false && console.log("Copying meta files...");
+    copyToDist("package.json", stagingOptions);
+    copyToDist("LICENSE", stagingOptions);
+
+    // Fast-swap: clear dist contents and move staged files in.
+    if (fs.existsSync(distDir)) {
+        for (const entry of fs.readdirSync(distDir)) {
+            fs.rmSync(join(distDir, entry), { recursive: true, force: true });
+        }
+    } else {
+        fs.mkdirSync(distDir, { recursive: true });
+    }
+
+    for (const entry of fs.readdirSync(stagingDir)) {
+        fs.renameSync(join(stagingDir, entry), join(distDir, entry));
+    }
+
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+}

package/packages/createBuildPackage.js

@@ -0,0 +1,7 @@
+import buildPackage from "./buildPackage.js";
+import { prepareOptions } from "../utils.js";
+
+export default config => async options => {
+    const preparedOptions = prepareOptions({ config, options });
+    return buildPackage(preparedOptions);
+};

package/packages/createWatchPackage.js

@@ -0,0 +1,7 @@
+import watchPackage from "./watchPackage.js";
+import { prepareOptions } from "../utils.js";
+
+export default config => async options => {
+    const preparedOptions = prepareOptions({ config, options });
+    return watchPackage(preparedOptions);
+};

package/packages/index.js

@@ -0,0 +1,4 @@
+export { default as watchPackage } from "./watchPackage.js";
+export { default as createWatchPackage } from "./createWatchPackage.js";
+export { default as buildPackage } from "./buildPackage.js";
+export { default as createBuildPackage } from "./createBuildPackage.js";