@serenity-is/tsbuild 9.1.6 → 10.0.3

package/dist/index.d.ts

@@ -1,65 +1,100 @@
-export const defaultEntryPointGlobs: string[];
-export const importAsGlobalsMapping: Record<string, string>;
-
-export interface TSBuildOptions {
+import esbuild from "esbuild";
+import { type GlobOptions } from "glob";
+export declare const defaultEntryPointGlobs: string[];
+/**
+ * Default mapping for importing modules as globals. corelib, domwise, extensions, pro.extensions, sleekgrid
+ * are all mapped to Serenity global namespace */
+export declare const importAsGlobalsMapping: Record<string, string>;
+export declare function safeGlobSync(globs: string[], options?: Omit<GlobOptions, "ignore">): string[];
+/** Default esbuild options used by TSBuild */
+export declare const tsbuildDefaults: Partial<import("esbuild").BuildOptions>;
+export interface TSBuildOptions extends Partial<import("esbuild").BuildOptions> {
+    /** Enable building of global iife bundles from Modules/Common/esm/bundles/*-bundle(.css|.ts) files to wwwroot/esm/bundles/. Default is false.
+      * If set to an object, uses the passed options for building global bundles. */
+    buildGlobalBundles?: boolean | TSBuildOptions;
     /** Enable bundling of dependencies, default is true */
     bundle?: boolean;
-
     /** Chunk names to generate when code splitting is enabled. Default is '_chunks/[name]-[hash]' */
-    chunkNames?: string[];
-
+    chunkNames?: string;
     /** True to enable the clean plugin. Default is true if splitting is true. */
-    clean?: boolean;
-
+    clean?: boolean | CleanPluginOptions;
+    /** Options for compressing output files. If specified, enables compression. Currently only available when writeIfChanged plugin is enabled */
+    compress?: CompressOptions;
     /**
-     * Determines the set of entry points that should be passed to the esbuild. 
+     * Determines the set of entry points that should be passed to the esbuild.
      * Only use to specify full paths of entry points manually if you calculated them yourself.
      * Prefer specifying entry point globs in sergen.json under TSBuild:EntryPoints which supports
      * globs and defaults to ['Modules/** /*Page.ts', 'Modules/** /*Page.tsx', 'Modules/** /ScriptInit.ts'] */
     entryPoints?: string[];
-
     /**
-     * A set of mappings to pass to the importAsGlobalsPlugin. If this is undefined or any object and the plugins 
+     * A set of mappings to pass to the importAsGlobalsPlugin. If this is undefined or any object and the plugins
      * is not specified, importAsGlobals plugin is enabled */
-    importAsGlobals?: Record<string, string>;
-
+    importAsGlobals?: Record<string, string> | null;
     /**
      * True to enable metafile generation by esbuild. Default is true.
      * If this is false, clean plugin won't work properly.
      */
     metafile?: boolean;
-
     /** True to enable minification. Default is true. */
     minify?: boolean;
-
     /** False to not call npmCopy automatically for entries in appsettings.bundles.json that start with `~/npm/`. Default is true.*/
     npmCopy?: boolean;
-
     /** Base directory for calculating output file locations in output directory. Default is "./" */
     outbase?: string;
-
     /** Base output directory. Default is wwwroot/esm */
-    outdir?: boolean;
-
+    outdir?: string;
     /** True to enable code splitting. Default is true unless --nosplit is passed in process arguments. */
     splitting?: boolean;
-
-    /** Set of plugins for esbuild */
-    plugins?: any[];
-
     /** Should source maps be generated. Default is true. */
     sourcemap?: boolean;
-
-    /* Javascript target for output files. Default is es6. */
     target?: string;
-
     /** True to watch, default is calculated from process args and true if it contains --watch */
     watch?: boolean;
+    /** Write output files only if contents have changed. Default is true. */
+    writeIfChanged?: boolean;
 }
-
-/** Processes passed options and converts it to options suitable for esbuild */
-export const esbuildOptions: (opt: TSBuildOptions) => any;
-export const build: (opt: TSBuildOptions) => Promise<void>;
-export function importAsGlobalsPlugin(mapping: Record<string, string>): any;
-export function cleanPlugin(): any;
-export function npmCopy(paths: string[], outdir?: string): void;
+/** Processes passed TSBuildOptions options and converts it to options suitable for esbuild */
+export declare const esbuildOptions: (opt: TSBuildOptions) => import("esbuild").BuildOptions;
+/** Default options for global iife bundle builds which is used when buildGlobalBundles is true or is an object */
+export declare const tsbuildGlobalBundleDefaults: Partial<TSBuildOptions>;
+/** Calls esbuild with passed options. By default, this is used to generate files under wwwroot/esm/ from entry points under Modules/
+ * but this can be changed by passing outdir and outbase, and other options. */
+export declare const build: (opt: TSBuildOptions) => Promise<void>;
+/** Plugin for importing modules as globals */
+export declare function importAsGlobalsPlugin(mapping: Record<string, string>): {
+    name: string;
+    setup(build: esbuild.PluginBuild): void;
+};
+/** Default options for cleanPlugin */
+export declare const cleanPluginDefaults: {
+    globs: string[];
+    logDeletedFiles: boolean;
+};
+/** Options for cleanPlugin */
+export interface CleanPluginOptions {
+    /** Glob patterns to include for cleaning. Default is ['** /*.js', '** /*.js.map', '** /*.css', '** /*.css.map'] */
+    globs?: string[];
+    /** Whether to log deleted files to console. Default is true */
+    logDeletedFiles?: boolean;
+}
+/** Plugin for cleaning output directory based on passed globs */
+export declare function cleanPlugin(opt: CleanPluginOptions): {
+    name: string;
+    setup(build: esbuild.PluginBuild): void;
+};
+export interface CompressOptions {
+    brotli?: boolean | {
+        quality?: number;
+    };
+    gzip?: boolean | {
+        level?: number;
+    };
+    extensions?: string[];
+}
+/** Plugin for writing files only if changed */
+export declare function writeIfChanged(opt?: CompressOptions): {
+    name: string;
+    setup(build: esbuild.PluginBuild): void;
+};
+/** Copies files from node_modules to outdir (wwwroot/npm by default). Paths are relative to node_modules. */
+export declare function npmCopy(paths: string[]): void;

package/dist/index.js

@@ -1,217 +1,301 @@
 import esbuild from "esbuild";
-import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
-import { dirname, join, relative, resolve } from "path";
+import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { globSync } from "glob";
+import pipe from "node:stream/promises";
+import { constants, createBrotliCompress, createGzip } from "node:zlib";
+import { dirname, isAbsolute, join, resolve, sep } from "path";
 
-export const defaultEntryPointGlobs = ['Modules/**/*Page.ts', 'Modules/**/*Page.tsx', 'Modules/**/ScriptInit.ts', 'Modules/**/*.mts'];
+export const defaultEntryPointGlobs = [
+    "Modules/**/*Page.ts",
+    "Modules/**/*Page.tsx",
+    "Modules/**/ScriptInit.ts",
+    "Modules/**/*.mts"
+];
 
 export const importAsGlobalsMapping = {
-    "@serenity-is/base": "Serenity",
     "@serenity-is/corelib": "Serenity",
-    "@serenity-is/corelib/q": "Q",
-    "@serenity-is/corelib/slick": "Slick",
-    "@serenity-is/sleekgrid": "Slick",
-    "@serenity-is/extensions": "Serenity.Extensions",
-    "@serenity-is/pro.extensions": "Serenity"
-}
-
-export const esbuildOptions = (opt) => {
+    "@serenity-is/domwise": "Serenity",
+    "@serenity-is/domwise/jsx-runtime": "Serenity",
+    "@serenity-is/extensions": "Serenity",
+    "@serenity-is/pro.extensions": "Serenity",
+    "@serenity-is/sleekgrid": "Serenity"
+};
 
-    opt = Object.assign({}, opt);
+export function safeGlobSync(globs, options = {}) {
+    const root = options.root || process.cwd();
+    const normalizePattern = (pattern) => {
+        let normalized = pattern.replace(/\\/g, "/");
+        if (normalized.startsWith("/")) {
+            normalized = "." + normalized;
+        } else if (!normalized.includes("/")) {
+            normalized = "**/" + normalized;
+        }
+        if (isAbsolute(normalized) || normalized.includes("..") || /^[a-zA-Z]:/.test(normalized)) {
+            throw new Error(`Invalid pattern: ${pattern}`);
+        }
+        return normalized;
+    };
+    globs = globs.map((x) => x?.trim()).filter((x) => x.length > 0);
+    const includes = globs.filter((x) => !x.startsWith("!")).map(normalizePattern);
+    const excludes = globs.filter((x) => x.startsWith("!")).map((x) => normalizePattern(x.substring(1)));
+    const results = globSync(includes, {
+        nodir: true,
+        ignore: excludes,
+        matchBase: true,
+        cwd: root,
+        ...options
+    });
+    const resolvedRoot = resolve(root);
+    return results.filter((file) => {
+        const fullPath = resolve(root, file);
+        return fullPath.startsWith(resolvedRoot + sep) || fullPath === resolvedRoot;
+    });
+}
 
-    var entryPointsRegEx;
-    if (opt.entryPointsRegEx !== undefined) {
-        entryPointsRegEx = opt.entryPointsRegEx;
-        delete opt.entryPointsRegEx;
-    }
+export const tsbuildDefaults = {
+    assetNames: "assets/[name]-[hash]",
+    bundle: true,
+    chunkNames: "_chunks/[name]-[hash]",
+    color: true,
+    format: "esm",
+    jsxSideEffects: true,
+    keepNames: true,
+    loader: {
+        ".woff2": "file",
+        ".woff": "file",
+        ".ttf": "file",
+        ".eot": "file",
+        ".svg": "file",
+        ".png": "file",
+        ".jpg": "file",
+        ".jpeg": "file",
+        ".gif": "file",
+        ".webp": "file"
+    },
+    logLevel: "info",
+    metafile: true,
+    minify: true,
+    outbase: "./",
+    outdir: "wwwroot/esm",
+    sourcemap: true,
+    target: "es2017"
+};
 
-    var entryPointRoots = ['Modules'];
-    if (opt.entryPointRoots !== undefined) {
-        entryPointRoots = opt.entryPointRoots;
-        delete opt.entryPointRoots;
+function isSplittingEnabled(opt) {
+    if (opt.splitting !== void 0) {
+        return !!opt.splitting;
     }
+    return (opt.format == null || opt.format === "esm") && !globalThis.process.argv.slice(2).some((x) => x == "--nosplit");
+}
 
+function cleanPluginOptions(opt) {
+    if (opt.plugins === void 0)
+        return null;
+    if (opt.clean === void 0 && isSplittingEnabled(opt) || opt.clean)
+        return opt.clean === true ? {} : opt.clean ?? {};
+    return null;
+}
 
-    var entryPoints = opt.entryPoints;
+export const esbuildOptions = (opt) => {
+    opt = Object.assign({}, opt);
+    if (opt.entryPointsRegex !== void 0 || opt.entryPointRoots !== void 0) {
+        throw new Error("TSBuildOptions.entryPointsRegex and entryPointRoots are deprecated, use TSBuild:EntryPoints in sergen.json.");
+    }
+    let entryPoints = opt.entryPoints;
     if (entryPoints === void 0) {
         let globs;
-        if (existsSync('sergen.json')) {
-            var json = readFileSync('sergen.json', 'utf8').trim();
-            var cfg = JSON.parse(json || {});
+        if (existsSync("sergen.json")) {
+            var json = readFileSync("sergen.json", "utf8").trim();
+            var cfg = JSON.parse(json || "{}");
             globs = cfg?.TSBuild?.EntryPoints;
-            if (globs != null && globs[0] === '+') {
+            if (globs != null && globs[0] === "+") {
                 globs = [...defaultEntryPointGlobs, ...globs.slice(1)];
             }
-            if (globs === void 0 &&
-                typeof cfg.Extends == "string" &&
-                existsSync(cfg.Extends)) {
-                json = readFileSync(cfg.Extends, 'utf8').trim();
-                cfg = JSON.parse(json || {});
+            if (globs === void 0 && typeof cfg.Extends == "string" && existsSync(cfg.Extends)) {
+                json = readFileSync(cfg.Extends, "utf8").trim();
+                cfg = JSON.parse(json || "{}");
                 globs = cfg?.TSBuild?.EntryPoints;
-                if (globs != null && globs[0] === '+') {
+                if (globs != null && globs[0] === "+") {
                     globs = [...defaultEntryPointGlobs, ...globs.slice(1)];
                 }
             }
         }
-
-        if (globs == null && !entryPointsRegEx) {
+        if (globs == null) {
             globs = defaultEntryPointGlobs;
         }
-
         if (globs != null) {
-            var include = globs.filter(x => !x.startsWith('!'));
-            var exclude = globs.filter(x => x.startsWith('!')).map(x => x.substring(1));
-            exclude.push(".git/**");
-            exclude.push("App_Data/**");
-            exclude.push("bin/**");
-            exclude.push("obj/**");
-            exclude.push("node_modules/**");
-            exclude.push("**/node_modules/**");
-
-            entryPoints = globSync(include, {
-                ignore: exclude,
-                nodir: true,
-                matchBase: true
-            });
-        }
-        else {
-            entryPoints = [];
-            entryPointRoots.forEach(root =>
-                scanDir(root)
-                    .filter(p => p.match(entryPointsRegEx))
-                    .forEach(p => entryPoints.push(root + '/' + p)));
+            globs.push("!.git/**");
+            globs.push("!App_Data/**");
+            globs.push("!bin/**");
+            globs.push("!obj/**");
+            globs.push("!node_modules/**");
+            entryPoints = safeGlobSync(globs);
         }
     }
-   
-    var splitting = opt.splitting;
-    if (splitting === undefined)
-        splitting = !process.argv.slice(2).some(x => x == "--nosplit");
-
-    var plugins = opt.plugins;
-    if (plugins === undefined) {
+    const splitting = isSplittingEnabled(opt);
+    let plugins = opt.plugins;
+    if (plugins === void 0) {
         plugins = [];
-        if ((opt.clean === undefined && splitting) || opt.clean)
-            plugins.push(cleanPlugin());
-        if (opt.importAsGlobals === undefined || opt.importAsGlobals)
+        const cleanOpt = cleanPluginOptions(opt);
+        if (cleanOpt != null)
+            plugins.push(cleanPlugin(cleanOpt));
+        if (opt.importAsGlobals === void 0 || opt.importAsGlobals)
             plugins.push(importAsGlobalsPlugin(opt.importAsGlobals ?? importAsGlobalsMapping));
     }
-
-    if (opt.write === undefined && opt.writeIfChanged === undefined || opt.writeIfChanged) {
-        plugins.push(writeIfChanged());
+    if (opt.write === void 0 && opt.writeIfChanged === void 0 || opt.writeIfChanged) {
+        plugins.push(writeIfChanged(opt.compress));
         opt.write = false;
     }
-
+    delete opt.compress;
     delete opt.clean;
     delete opt.importAsGlobals;
     delete opt.writeIfChanged;
-
-    return Object.assign({
-        absWorkingDir: resolve('./'),
-        bundle: true,
-        chunkNames: '_chunks/[name]-[hash]',
-        color: true,
-        entryPoints: entryPoints,
-        format: 'esm',
-        keepNames: true,
-        logLevel: 'info',
-        metafile: true,
-        minify: true,
-        outbase: "./",
-        outdir: 'wwwroot/esm',
+    if (opt.sourceRoot === void 0) {
+        if (existsSync("package.json")) {
+            let pkgId = JSON.parse(readFileSync("package.json", "utf8").trim() || "{}").name;
+            if (pkgId.startsWith("@serenity-is/")) {
+                opt.sourceRoot = "https://packages.serenity.is/" + pkgId.substring(13) + "/Modules/";
+            }
+        }
+        opt.sourceRoot ??= "Modules";
+    }
+    return {
+        ...tsbuildDefaults,
+        absWorkingDir: resolve("./"),
+        entryPoints,
         plugins,
-        sourcemap: true,
-        splitting: splitting,
-        target: 'es2017',
-        watch: process.argv.slice(2).some(x => x == "--watch"),
-    }, opt);
-}
+        splitting,
+        // @ts-ignore
+        watch: process.argv.slice(2).some((x) => x == "--watch"),
+        ...opt
+    };
+};
+
+export const tsbuildGlobalBundleDefaults = {
+    entryPoints: [
+        "Modules/Common/bundles/*-bundle.ts",
+        "Modules/Common/bundles/*-bundle.css",
+        "Modules/Common/bundles/*-bundle.rtl.css"
+    ],
+    format: "iife",
+    importAsGlobals: null,
+    outdir: "wwwroot/esm/bundles/",
+    outbase: "Modules/Common/bundles",
+    watch: false
+};
 
 export const build = async (opt) => {
-    if (opt?.npmCopy !== false &&
-        existsSync('appsettings.bundles.json')) {
-        const bundlesJson = readFileSync('appsettings.bundles.json', 'utf8').trim();
-        const bundlesCfg = JSON.parse(bundlesJson || {});
+    if (opt.buildGlobalBundles) {
+        const buildGlobalBundles = {
+            ...tsbuildGlobalBundleDefaults,
+            ...opt.buildGlobalBundles === true ? {} : opt.buildGlobalBundles
+        };
+        delete opt.buildGlobalBundles;
+        console.log("\x1B[32mBuilding global bundles...\x1B[0m");
+        await build(buildGlobalBundles);
+        let cleanOpt = cleanPluginOptions(opt);
+        if (cleanOpt != null) {
+            opt.clean = {
+                ...cleanOpt,
+                globs: [
+                    "!./bundles/**",
+                    ...cleanOpt.globs ?? cleanPluginDefaults.globs
+                ]
+            };
+        }
+    }
+    if (opt?.npmCopy !== false && existsSync("appsettings.bundles.json")) {
+        const bundlesJson = readFileSync("appsettings.bundles.json", "utf8").trim();
+        const bundlesCfg = JSON.parse(bundlesJson || "{}");
         const bundles = Object.values(bundlesCfg?.CssBundling?.Bundles || {}).concat(Object.values(bundlesCfg?.ScriptBundling?.Bundles || {}));
         let paths = [];
-        Object.values(bundles).filter(x => x?.length).forEach(bundle => {
-            paths.push(...bundle.filter(f => f?.startsWith('~/npm/')).map(f => f.substring(5)));
+        Object.values(bundles).filter((x) => x?.length).forEach((bundle) => {
+            paths.push(...bundle.filter((f) => f?.startsWith("~/npm/")).map((f) => f.substring(5)));
         });
-        paths = paths.filter((v, i, a) => a.indexOf(v) === i); // unique
+        paths = paths.filter((v, i, a) => a.indexOf(v) === i);
         if (paths.length) {
             npmCopy(paths);
-        }   
+        }
     }
-
     delete opt?.npmCopy;
-
-    opt = esbuildOptions(opt);
-
-    if (opt.watch) {
-        // this somehow resolves the issue that when debugging is stopped
-        // in Visual Studio, the node process stays alive
+    const esopt = esbuildOptions(opt);
+    if (esopt.watch) {
         setInterval(() => {
             process.stdout.write("");
-        }, 5000);
-
-        delete opt.watch;
-        const context = await esbuild.context(opt);
+        }, 5e3);
+        delete esopt.watch;
+        const context = await esbuild.context(esopt);
         await context.watch();
-    }
-    else {
-        delete opt.watch;
-        await esbuild.build(opt);
+    } else {
+        delete esopt.watch;
+        await esbuild.build(esopt);
     }
 };
 
-function scanDir(dir, org) {
-    return readdirSync(dir).reduce((files, file) => {
-        const absolute = join(dir, file);
-        return [...files, ...(statSync(absolute).isDirectory()
-            ? scanDir(absolute, org || dir)
-            : [relative(org || dir, absolute)])]
-    }, []);
-}
-
-// https://github.com/evanw/esbuild/issues/337
 export function importAsGlobalsPlugin(mapping) {
     const escRe = (s) => s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-    const filter = new RegExp(Object.keys(mapping).map((mod) =>
-        `^${escRe(mod)}$`).join("|"));
-
+    const filter = new RegExp(Object.keys(mapping).map((mod) => `^${escRe(mod)}$`).join("|"));
     return {
         name: "global-imports",
-        setup(build) {
-            build.onResolve({ filter }, (args) => {
+        setup(build2) {
+            build2.onResolve({ filter }, (args) => {
                 if (!mapping[args.path])
                     throw new Error("Unknown global: " + args.path);
                 return { path: mapping[args.path], namespace: "external-global" };
             });
-
-            build.onLoad({ filter: /.*/, namespace: "external-global" },
+            build2.onLoad(
+                { filter: /.*/, namespace: "external-global" },
                 async (args) => {
                     return { contents: `module.exports = ${args.path};`, loader: "js" };
-                });
+                }
+            );
         }
     };
 }
 
-export function cleanPlugin() {
+export const cleanPluginDefaults = {
+    globs: [
+        "*.css",
+        "*.css.map",
+        "*.js",
+        "*.js.map",
+        "*.jpg",
+        "*.png",
+        "*.gif",
+        "*.svg",
+        "*.woff",
+        "*.woff2",
+        "*.ttf",
+        "*.eot"
+    ],
+    logDeletedFiles: true
+};
+function cleanPlugin(opt) {
+    opt = Object.assign({}, cleanPluginDefaults, opt ?? {});
     return {
-        name: 'clean',
-        setup(build) {
-            build.onEnd(result => {
+        name: "clean",
+        setup(build2) {
+            build2.onEnd((result) => {
                 try {
+                    const outdir = build2.initialOptions.outdir;
                     const { outputs } = result.metafile ?? {};
-                    if (!outputs || !existsSync(build.initialOptions.outdir))
+                    if (!outputs || !existsSync(outdir))
                         return;
-
-                    const outputFiles = new Set(Object.keys(outputs));
-                    scanDir(build.initialOptions.outdir).forEach(file => {
-                        if (!file.endsWith('.js') && !file.endsWith('.js.map') && !file.endsWith('.css') && !file.endsWith('.css.map'))
-                            return;
-                        if (!outputFiles.has(join(build.initialOptions.outdir, file).replace(/\\/g, '/'))) {
-                            console.log('esbuild clean: deleting extra file ' + file);
-                            rmSync(join(build.initialOptions.outdir, file));
+                    const outputFiles = new Set(Object.keys(outputs).map((x) => x.replace(/\\/g, "/")));
+                    const existingFiles = safeGlobSync(opt.globs || [], {
+                        cwd: outdir
+                    }).map((x) => join(outdir, x).replace(/\\/g, "/"));
+                    existingFiles.forEach((file) => {
+                        if (!outputFiles.has(file)) {
+                            if (opt.logDeletedFiles ?? true)
+                                console.log(`esbuild clean: \x1B[33mdeleting extra file ${file}\x1B[0m`);
+                            rmSync(file);
+                            if (existsSync(file + ".gz")) {
+                                rmSync(file + ".gz");
+                            }
+                            if (existsSync(file + ".br")) {
+                                rmSync(file + ".br");
+                            }
                         }
                     });
                 } catch (e) {
@@ -219,59 +303,91 @@ export function cleanPlugin() {
                 }
             });
         }
-    }
-}
-
-export function checkIfTrigger() {
-    // nop
+    };
 }
 
-export function writeIfChanged() {
+export function writeIfChanged(opt) {
+    const compressExtensions = opt?.extensions ?? [".css", ".js", ".svg", ".json"];
     return {
         name: "write-if-changed",
-        setup(build) {
-            build.onEnd(result => {
-                result.outputFiles?.forEach(file => {
+        setup(build2) {
+            build2.onEnd(async (result) => {
+                const start = (/* @__PURE__ */ new Date()).getTime();
+                let compressed = 0;
+                let written = 0;
+                let checkedFiles = 0;
+                let outputFiles = result.outputFiles || [];
+                for (const file of outputFiles) {
+                    checkedFiles++;
+                    const compressFile = async () => {
+                        if ((opt?.brotli || opt?.gzip) && compressExtensions.some((ext) => file.path?.endsWith(ext))) {
+                            if (opt.brotli) {
+                                await pipe.pipeline(
+                                    createReadStream(file.path),
+                                    createBrotliCompress({
+                                        [constants.BROTLI_PARAM_QUALITY]: typeof opt.brotli === "object" && opt.brotli.quality || 4
+                                    }),
+                                    createWriteStream(`${file.path}.br`)
+                                );
+                                compressed++;
+                            }
+                            if (opt.gzip) {
+                                await pipe.pipeline(
+                                    createReadStream(file.path),
+                                    createGzip({ level: typeof opt.gzip === "object" && opt.gzip.level || 7 }),
+                                    createWriteStream(`${file.path}.gz`)
+                                );
+                                compressed++;
+                            }
+                        }
+                    };
                     if (existsSync(file.path)) {
                         const old = readFileSync(file.path);
-                        if (old.equals(file.contents))
-                            return;
-                    }
-                    else {
+                        if (old.equals(file.contents)) {
+                            if (opt?.brotli && !existsSync(file.path + ".br") || opt?.gzip && !existsSync(file.path + ".gz")) {
+                                await compressFile();
+                            }
+                            continue;
+                        }
+                    } else {
                         mkdirSync(dirname(file.path), { recursive: true });
                     }
-                    writeFileSync(file.path, file.text);
-                });
+                    writeFileSync(file.path, file.contents);
+                    written++;
+                    await compressFile();
+                }
+                const end = (/* @__PURE__ */ new Date()).getTime();
+                if (written > 0 || compressed > 0)
+                    console.log(`esbuild write: \x1B[32mChecked ${checkedFiles} output files in ${end - start} ms, changed ${written}, compressed ${compressed}\x1B[0m`);
+                else
+                    console.log(`esbuild write: \x1B[32mChecked ${checkedFiles} output files in ${end - start} ms, none changed\x1B[0m`);
+                await Promise.resolve();
             });
         }
     };
 }
 
 export function npmCopy(paths) {
-    paths.forEach(path => {
+    paths.forEach((path) => {
         const srcFile = join("node_modules", path);
         const dstfile = join("wwwroot/npm", path);
         if (!existsSync(srcFile)) {
             console.warn(`Source file not found: ${srcFile}`);
             return;
         }
-
-        (function() {
+        (function () {
             const srcContent = readFileSync(srcFile);
             if (existsSync(dstfile)) {
                 if (readFileSync(dstfile).equals(srcContent))
                     return;
-            }
-            else {
+            } else {
                 mkdirSync(dirname(dstfile), { recursive: true });
             }
             console.log(`Copying ${srcFile} to ${dstfile}`);
             writeFileSync(dstfile, srcContent);
         })();
-
         const js = path.endsWith(".js");
-        if ((js && !path.endsWith(".min.js")) ||
-            (path.endsWith(".css") && !path.endsWith(".min.css"))) {
+        if (js && !path.endsWith(".min.js") || path.endsWith(".css") && !path.endsWith(".min.css")) {
             const ext = js ? ".min.js" : ".min.css";
             const srcMinFile = srcFile.substring(0, srcFile.length - (js ? 3 : 4)) + ext;
             const dstMinFile = dstfile.substring(0, dstfile.length - (js ? 3 : 4)) + ext;
@@ -284,4 +400,4 @@ export function npmCopy(paths) {
             }
         }
     });
-}
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@serenity-is/tsbuild",
-  "version": "9.1.6",
+  "version": "10.0.3",
   "author": "Serenity (https://serenity.is)",
   "bugs": "https://github.com/serenity-is/serenity/issues",
   "description": "Serenity ESBuild functions",
   "dependencies": {
     "esbuild": "0.27.0",
-    "glob": "12.0.0"
+    "glob": "13.0.0"
   },
   "exports": {
     ".": {