@webiny/build-tools 0.0.0-unstable.61c048f412

package/packages/buildPackage/babelCompile.js

@@ -0,0 +1,103 @@
+import fs from "fs";
+import { dirname, extname, join, parse, relative } from "path";
+import * as babel from "@babel/core";
+import glob from "fast-glob";
+
+const BABEL_COMPILE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+const BABEL_SKIP_EXTENSIONS = [".d.ts"];
+
+const withSourceMapUrl = (file, code) => {
+    const { name } = parse(file);
+    return [code, "", `//# sourceMappingURL=${name}.js.map`].join("\n");
+};
+
+const getDistCopyFilePath = ({ file, cwd }) => {
+    const relativeDir = relative(cwd, file);
+    return join(cwd, relativeDir.replace("src", "dist"));
+};
+
+const getDistFilePaths = ({ file, cwd }) => {
+    const { dir, name } = parse(file);
+
+    const relativeDir = relative(cwd, dir);
+
+    const code = join(cwd, relativeDir.replace("src", "dist"), name + ".js");
+    const map = join(cwd, relativeDir.replace("src", "dist"), name + ".js.map");
+    return { code, map };
+};
+
+export const babelCompile = async ({ cwd }) => {
+    // We're passing "*.*" just because we want to copy all files that cannot be compiled.
+    // We want to have the same behaviour that the Babel CLI's "--copy-files" flag provides.
+    const pattern = join(cwd, "src/**/*.*").replace(/\\/g, "/");
+    const files = glob.sync(pattern, {
+        onlyFiles: true,
+        dot: true
+    });
+
+    const compilations = [];
+    const copies = [];
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        if (
+            fileEndsWith(file, BABEL_COMPILE_EXTENSIONS) &&
+            !fileEndsWith(file, BABEL_SKIP_EXTENSIONS)
+        ) {
+            compilations.push(
+                babel
+                    .transformFileAsync(file, {
+                        cwd,
+                        sourceMaps: true
+                    })
+                    .then(results => [file, results])
+            );
+            continue;
+        }
+
+        // All other files should be copied as-is.
+        copies.push(copyFile(file, cwd));
+    }
+
+    // At this point, just wait for compilations to be completed, so we can proceed with writing the files ASAP.
+    await Promise.all(compilations);
+
+    const writes = [];
+    for (let i = 0; i < compilations.length; i++) {
+        const [file, result] = await compilations[i];
+        const { code, map } = result;
+
+        const paths = getDistFilePaths({ file, cwd });
+        fs.mkdirSync(dirname(paths.code), { recursive: true });
+
+        // Save the compiled JS file.
+        writes.push(fs.promises.writeFile(paths.code, withSourceMapUrl(file, code), "utf8"));
+
+        // Save source maps file.
+        const mapJson = JSON.stringify(map);
+        writes.push(fs.promises.writeFile(paths.map, mapJson, "utf8"));
+    }
+
+    // Wait until all files have been written to disk.
+    return Promise.all([...writes, ...copies]);
+};
+
+function copyFile(file, cwd) {
+    return new Promise((resolve, reject) => {
+        try {
+            const destPath = getDistCopyFilePath({ file, cwd });
+            if (!fs.existsSync(dirname(destPath))) {
+                fs.mkdirSync(dirname(destPath), { recursive: true });
+            }
+
+            fs.copyFileSync(file, destPath);
+            resolve();
+        } catch (e) {
+            reject(e);
+        }
+    });
+}
+
+function fileEndsWith(file, extensions) {
+    return extensions.some(ext => file.endsWith(ext));
+}

package/packages/buildPackage/copyToDist.js

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

package/packages/buildPackage/tsAliasReplacer.js

@@ -0,0 +1,39 @@
+import { dirname, relative } from "path";
+import fg from "fast-glob";
+import fs from "fs";
+
+export const replaceTscAliases = async ({ distDir, cwd, debug = false }) => {
+    const dtsFiles = await fg("**/*.d.ts", {
+        cwd: distDir,
+        absolute: true
+    });
+
+    for (const dtsFile of dtsFiles) {
+        let content = fs.readFileSync(dtsFile, "utf8");
+        let modified = false;
+
+        // Replace all imports/exports with ~/ alias
+        content = content.replace(
+            /(from\s+["'])~\/([^"']+)(["'])/g,
+            (match, prefix, importPath, suffix) => {
+                modified = true;
+                // Calculate relative path from current file to dist root
+                const fileDir = dirname(dtsFile);
+                const relativePath = relative(fileDir, distDir);
+                const finalPath = relativePath
+                    ? `${relativePath}/${importPath}`
+                    : `./${importPath}`;
+                // Normalize to always start with ./
+                const normalized = finalPath.startsWith(".") ? finalPath : `./${finalPath}`;
+                return `${prefix}${normalized}${suffix}`;
+            }
+        );
+
+        if (modified) {
+            fs.writeFileSync(dtsFile, content, "utf8");
+            if (debug) {
+                console.log(`Resolved ~ aliases in: ${relative(cwd, dtsFile)}`);
+            }
+        }
+    }
+};

package/packages/buildPackage/tsCompile.js

@@ -0,0 +1,69 @@
+import { join } from "path";
+import ts from "typescript";
+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");
+
+    let { config: readTsConfig } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+
+    if (overrides.tsConfig) {
+        if (typeof overrides.tsConfig === "function") {
+            readTsConfig = overrides.tsConfig(readTsConfig);
+        } else {
+            merge(readTsConfig, overrides.tsConfig);
+        }
+
+        if (debug) {
+            console.log(`"tsconfig.build.json" overridden. New config:`);
+            console.log(readTsConfig);
+        }
+    }
+    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, cwd);
+
+    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({
+        projectReferences,
+        options,
+        rootNames: filteredFileNames,
+        configFileParsingDiagnostics: errors
+    });
+
+    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("../")) {
+                ts.sys.writeFile(fileName, data, writeByteOrderMark);
+            }
+        }
+    );
+
+    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics, errors);
+
+    if (allDiagnostics.length) {
+        const formatHost = {
+            getCanonicalFileName: path => path,
+            getCurrentDirectory: () => cwd,
+            getNewLine: () => ts.sys.newLine
+        };
+        const message = ts.formatDiagnostics(allDiagnostics, formatHost);
+        if (message) {
+            throw { message };
+        }
+    }
+
+    if (emitSkipped) {
+        throw { message: "TypeScript compilation failed." };
+    }
+
+    // Resolve ~ path aliases in .d.ts files
+    const distDir = options.outDir || join(cwd, "dist");
+    await replaceTscAliases({ distDir, cwd, debug });
+};

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,40 @@
+import * as rimraf from "rimraf";
+import { join } from "path";
+import { babelCompile } from "./buildPackage/babelCompile.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;
+    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...");
+
+    // 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 });
+
+    await babelCompile(options);
+    await tsCompile(options);
+
+    options.logs !== false && console.log("Copying meta files...");
+    copyToDist("package.json", options);
+    copyToDist("LICENSE", options);
+
+    const duration = (new Date() - start) / 1000;
+    options.logs !== false && console.log(`Done! Build finished in ${duration + "s"}.`);
+
+    return { duration };
+};

package/packages/createBabelConfigForNode.js

@@ -0,0 +1,19 @@
+export default ({ path }) => {
+    return {
+        presets: [
+            ["@babel/preset-react", { useBuiltIns: true }],
+            ["@babel/preset-typescript", { isTSX: true, allExtensions: true }]
+        ],
+        plugins: [
+            [
+                "babel-plugin-module-resolver",
+                {
+                    cwd: path,
+                    alias: {
+                        "~": "./src"
+                    }
+                }
+            ]
+        ]
+    };
+};

package/packages/createBabelConfigForReact.js

@@ -0,0 +1,20 @@
+export default ({ path }) => ({
+    presets: [
+        ["@babel/preset-react", { useBuiltIns: true }],
+        ["@babel/preset-typescript", { isTSX: true, allExtensions: true }]
+    ],
+    plugins: [
+        "babel-plugin-macros",
+        "@babel/plugin-proposal-throw-expressions",
+        ["@emotion/babel-plugin", { autoLabel: "dev-only" }],
+        [
+            "babel-plugin-module-resolver",
+            {
+                cwd: path,
+                alias: {
+                    "~": "./src"
+                }
+            }
+        ]
+    ]
+});

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/createSwcConfigForNode.js

@@ -0,0 +1,45 @@
+import readJsonSync from "read-json-sync";
+
+export default ({ path, esm }) => {
+    return {
+        presets: [
+            [
+                "@babel/preset-env",
+                {
+                    targets: {
+                        node: "18"
+                    },
+                    modules: esm ? false : "auto",
+                    exclude: [
+                        "transform-typeof-symbol",
+                        "@babel/plugin-proposal-optional-chaining",
+                        "@babel/plugin-proposal-nullish-coalescing-operator",
+                        "@babel/plugin-proposal-class-properties",
+                        "@babel/plugin-transform-async-to-generator",
+                        "@babel/plugin-transform-regenerator",
+                        "@babel/plugin-proposal-dynamic-import"
+                    ]
+                }
+            ],
+            "@babel/preset-typescript"
+        ],
+        plugins: [
+            [
+                "@babel/plugin-transform-runtime",
+                {
+                    useESModules: !!esm,
+                    version: readJsonSync(require.resolve("@babel/runtime/package.json")).version
+                }
+            ],
+            [
+                "babel-plugin-module-resolver",
+                {
+                    cwd: path,
+                    alias: {
+                        "~": "./src"
+                    }
+                }
+            ]
+        ]
+    };
+};

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,6 @@
+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";
+export { default as createBabelConfigForNode } from "./createBabelConfigForNode.js";
+export { default as createBabelConfigForReact } from "./createBabelConfigForReact.js";

package/packages/watchPackage.js

@@ -0,0 +1,117 @@
+import path from "path";
+import fs from "fs/promises";
+import { transformFileAsync } from "@babel/core";
+import chokidar from "chokidar";
+import baseFs from "node:fs";
+
+let compilationQueue = [];
+let debounceTimer = null;
+const DEBOUNCE_DELAY = 1000; // 1 second
+
+const flushCompilationQueue = () => {
+    if (compilationQueue.length > 0) {
+        if (compilationQueue.length === 1) {
+            console.log(`Successfully compiled ${compilationQueue[0]}.`);
+        } else {
+            console.log(`Successfully compiled ${compilationQueue.length} files.`);
+        }
+        compilationQueue = [];
+    }
+};
+
+const logCompilation = inputPathRelative => {
+    compilationQueue.push(inputPathRelative);
+
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+        flushCompilationQueue();
+    }, DEBOUNCE_DELAY);
+};
+
+const getBabelFile = cwd => {
+    const babelJs = path.join(cwd, ".babelrc.js");
+    const babelCjs = path.join(cwd, ".babelrc.cjs");
+
+    if (baseFs.existsSync(babelJs)) {
+        return babelJs;
+    } else if (baseFs.existsSync(babelCjs)) {
+        return babelCjs;
+    }
+    throw new Error("No Babel configuration file found (.babelrc.js or .babelrc.cjs).");
+};
+
+const compileFile = async (cwd, inputPath, outputPath) => {
+    const inputPathRelative = path.relative(cwd, inputPath);
+
+    const configFile = getBabelFile(cwd);
+
+    const result = await transformFileAsync(inputPath, {
+        configFile: configFile,
+        sourceMaps: true
+    });
+
+    if (!result || !result.code) {
+        throw new Error(`Failed to compile: ${inputPath}`);
+    }
+
+    // Write compiled file
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, result.code);
+
+    // Write source map
+    if (result.map) {
+        await fs.writeFile(`${outputPath}.map`, JSON.stringify(result.map));
+    }
+
+    logCompilation(inputPathRelative);
+};
+
+const srcToDist = filePath =>
+    path.join(
+        filePath
+            .replace(`${path.sep}src${path.sep}`, `${path.sep}dist${path.sep}`)
+            .replace(/\.(ts|tsx)$/, ".js")
+    );
+
+export default async options => {
+    const srcDir = path.join(options.cwd, "src");
+
+    // Watch the src directory recursively for new files
+    const watcher = chokidar.watch(srcDir, {
+        ignored: /(^|[\/\\])\../, // ignore dotfiles
+        persistent: true,
+        ignoreInitial: false
+    });
+
+    const isTsFile = filePath => /\.(ts|tsx)$/.test(filePath);
+
+    watcher.on("add", async srcPath => {
+        if (!isTsFile(srcPath)) {
+            return;
+        }
+
+        const distPath = srcToDist(srcPath);
+
+        try {
+            await compileFile(options.cwd, srcPath, distPath);
+        } catch (err) {
+            console.error("Error compiling:", err);
+        }
+    });
+
+    watcher.on("change", async srcPath => {
+        if (!isTsFile(srcPath)) {
+            return;
+        }
+
+        const distPath = srcToDist(srcPath);
+
+        try {
+            await compileFile(options.cwd, srcPath, distPath);
+        } catch (err) {
+            console.error("Error compiling:", err);
+        }
+    });
+
+    console.log("Watching for changes...");
+};

package/traverseLoaders.js

@@ -0,0 +1,14 @@
+/**
+ * A utility to recursively traverse loaders and execute the "onLoader" callback.
+ */
+export const traverseLoaders = (loaders, onLoader) => {
+    for (const loader of loaders) {
+        if (loader.oneOf) {
+            traverseLoaders(loader.oneOf, onLoader);
+        } else if (loader.use) {
+            traverseLoaders(loader.use, onLoader);
+        } else {
+            onLoader(loader);
+        }
+    }
+};

package/utils/PackageJson.backup.ts

@@ -0,0 +1,46 @@
+// We'll use this class once the package is converted to TS!
+
+import readJson from "read-json-sync";
+import findUp from "find-up";
+
+export class PackageJson {
+    private readonly filePath: string;
+    private readonly json: Record<string, any>;
+
+    static fromFile(filePath: string) {
+        return new PackageJson(filePath, readJson(filePath));
+    }
+
+    static async findClosest(fromPath: string) {
+        const closestPackageJson = await findUp("package.json", { cwd: fromPath });
+        if (!closestPackageJson) {
+            throw Error(`Failed to find ${fromPath}`);
+        }
+        return PackageJson.fromFile(closestPackageJson);
+    }
+
+    static async fromPackage(packageName: string, cwd?: string) {
+        const jsonPath = await findUp(`node_modules/${packageName}/package.json`, {
+            cwd: cwd ?? process.cwd()
+        });
+
+        if (!jsonPath) {
+            throw Error(`Failed to find package ${packageName}`);
+        }
+
+        return PackageJson.fromFile(jsonPath);
+    }
+
+    private constructor(filePath: string, json: Record<string, any>) {
+        this.filePath = filePath;
+        this.json = json;
+    }
+
+    getLocation() {
+        return this.filePath;
+    }
+
+    getJson() {
+        return this.json;
+    }
+}

package/utils/PackageJson.d.ts

@@ -0,0 +1,33 @@
+export declare class PackageJson {
+    private readonly filePath: string;
+    private readonly json: Record<string, any>;
+
+    private constructor(filePath: string, json: Record<string, any>);
+
+    /**
+     * Load a PackageJson instance from a given file path.
+     */
+    static fromFile(filePath: string): PackageJson;
+
+    /**
+     * Find the closest package.json starting from the given path.
+     * Throws if no package.json is found.
+     */
+    static findClosest(fromPath: string): Promise<PackageJson>;
+
+    /**
+     * Load a PackageJson instance from a package in node_modules.
+     * Throws if the package.json cannot be found.
+     */
+    static fromPackage(packageName: string, cwd?: string): Promise<PackageJson>;
+
+    /**
+     * Get the absolute path to this package.json file.
+     */
+    getLocation(): string;
+
+    /**
+     * Get the raw JSON contents of the package.json file.
+     */
+    getJson(): Record<string, any>;
+}