@serenity-is/tsbuild 10.0.3 → 10.0.9

package/dist/index.js

@@ -1,3 +1,4 @@
+import { init as esmlInit, parse as esmlParse } from "es-module-lexer";
 import esbuild from "esbuild";
 import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { globSync } from "glob";
@@ -60,6 +61,7 @@ export const tsbuildDefaults = {
     format: "esm",
     jsxSideEffects: true,
     keepNames: true,
+    lineLimit: 1000,
     loader: {
         ".woff2": "file",
         ".woff": "file",
@@ -73,12 +75,15 @@ export const tsbuildDefaults = {
         ".webp": "file"
     },
     logLevel: "info",
+    logOverride: {
+        "empty-glob": "silent"
+    },
     metafile: true,
     minify: true,
     outbase: "./",
     outdir: "wwwroot/esm",
     sourcemap: true,
-    target: "es2017"
+    target: "es2022"
 };
 
 function isSplittingEnabled(opt) {
@@ -89,9 +94,9 @@ function isSplittingEnabled(opt) {
 }
 
 function cleanPluginOptions(opt) {
-    if (opt.plugins === void 0)
+    if (opt.plugins !== void 0)
         return null;
-    if (opt.clean === void 0 && isSplittingEnabled(opt) || opt.clean)
+    if ((opt.clean === void 0 && isSplittingEnabled(opt)) || opt.clean)
         return opt.clean === true ? {} : opt.clean ?? {};
     return null;
 }
@@ -134,18 +139,30 @@ export const esbuildOptions = (opt) => {
     }
     const splitting = isSplittingEnabled(opt);
     let plugins = opt.plugins;
+
     if (plugins === void 0) {
         plugins = [];
+
+        // clean and import plugins are only added if user didn't provide custom plugins
         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 === void 0 && opt.writeIfChanged === void 0 || opt.writeIfChanged) {
+    else {
+        if (opt.clean)
+            console.warn("TSBuildOptions.clean is ignored when custom plugins are provided.");
+        if (opt.importAsGlobals)
+            console.warn("TSBuildOptions.importAsGlobals is ignored when custom plugins are provided.");
+    }
+
+    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;
@@ -173,10 +190,16 @@ export const esbuildOptions = (opt) => {
 
 export const tsbuildGlobalBundleDefaults = {
     entryPoints: [
+        "Modules/Common/bundles/*.bundle.ts",
         "Modules/Common/bundles/*-bundle.ts",
+        "Modules/Common/bundles/*.bundle.css",
         "Modules/Common/bundles/*-bundle.css",
+        "Modules/Common/bundles/*.bundle.rtl.css",
         "Modules/Common/bundles/*-bundle.rtl.css"
     ],
+    external: [
+        "@serenity-is/tiptap"
+    ],
     format: "iife",
     importAsGlobals: null,
     outdir: "wwwroot/esm/bundles/",
@@ -232,20 +255,125 @@ export const build = async (opt) => {
     }
 };
 
+const serenityModuleTest = {
+    "@serenity-is/corelib": "PropertyGrid",
+    "@serenity-is/domwise": "observeSignal",
+    "@serenity-is/domwise/jsx-runtime": "jsx",
+    "@serenity-is/extensions": "GridEditorBase",
+    "@serenity-is/pro.extensions": "EnhancedLayout",
+    "@serenity-is/sleekgrid": "SleekGrid"
+}
+
 export function importAsGlobalsPlugin(mapping) {
     const escRe = (s) => s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
     const filter = new RegExp(Object.keys(mapping).map((mod) => `^${escRe(mod)}$`).join("|"));
+    let serenityModuleContents;
     return {
         name: "global-imports",
-        setup(build2) {
-            build2.onResolve({ filter }, (args) => {
+        setup(build) {
+            build.onResolve({ filter }, (args) => {
+                if (args.namespace === "skip-external-global") {
+                    return;
+                }
                 if (!mapping[args.path])
                     throw new Error("Unknown global: " + args.path);
                 return { path: mapping[args.path], namespace: "external-global" };
             });
-            build2.onLoad(
+            build.onLoad(
                 { filter: /.*/, namespace: "external-global" },
                 async (args) => {
+                    if (args.path === "Serenity") {
+                        if (serenityModuleContents === void 0) {
+                            const initOpt = build?.initialOptions || {};
+                            const absWorkingDir = initOpt.absWorkingDir || process.cwd();
+                            const allNames = new Set();
+                            const nameByModule = {};
+                            const moduleTest = {};
+                            try {
+                                await esmlInit;
+                                for (const [mod, ns] of Object.entries(mapping)) {
+                                    if (ns === "Serenity") {
+                                        const resResult = await build.resolve(mod, {
+                                            resolveDir: absWorkingDir,
+                                            kind: "import-statement",
+                                            namespace: "skip-external-global"
+                                        });
+                                        if (resResult?.errors?.length || !resResult?.path)
+                                            continue;
+
+                                        let path = resResult.path;
+                                        if (resResult.external) {
+                                            path = null;
+                                            let currentPath = absWorkingDir;
+                                            const actualMod = mod == "@serenity-is/domwise/jsx-runtime" ? "@serenity-is/domwise" : mod;
+                                            const actualFile = mod == "@serenity-is/domwise/jsx-runtime" ? "dist/jsx-runtime.js" : "dist/index.js";
+                                            let tries = 0;
+                                            while (tries++ < 100) {
+                                                const nmPath = join(currentPath, "node_modules", actualMod, actualFile);
+                                                if (existsSync(nmPath)) {
+                                                    path = nmPath;
+                                                    break;
+                                                }
+                                                currentPath = dirname(currentPath);
+                                                if (!currentPath.length)
+                                                    break;
+                                            }
+                                        }
+                                        if (!path)
+                                            continue;
+                                        const source = readFileSync(path, "utf8");
+                                        const [_, exports] = esmlParse(source);
+                                        nameByModule[mod] ??= new Set();
+                                        if (!moduleTest[mod] && serenityModuleTest[mod]) {
+                                            moduleTest[mod] = serenityModuleTest[mod];
+                                        }
+                                        for (const exp of exports) {
+                                            if (exp.n !== "default" && exp.n && exp.n.length > 0) {
+                                                allNames.add(exp.n);
+                                                nameByModule[mod].add(exp.n);
+                                            }
+                                        }
+                                    }
+                                }
+
+                                if (allNames.size > 0) {
+                                    const exportNames = Array.from(allNames).sort().join(", ");
+                                    const sb = [];
+                                    sb.push(`if (typeof Serenity === "undefined") globalThis.Serenity = Object.create(null);`);
+                                    if (initOpt.format === "esm" && Object.keys(moduleTest).length > 0) {
+                                        sb.push(`
+const t = ${JSON.stringify(moduleTest)};
+for (const [k, v] of Object.entries(t)) {
+    if (v in Serenity) continue;
+    try {
+        const m = await import(k);
+        for (const n of Object.keys(m)) {
+            if (!(n in Serenity)) Serenity[n] = m[n];
+        }
+    } catch (e) { console.warn(e); }
+}`);
+                                    }
+
+                                    sb.push(`const { ${exportNames} } = Serenity;`);
+                                    sb.push(`export { ${exportNames} };`);
+                                    serenityModuleContents = sb.join("\n");
+                                }
+                            }
+                            catch (e) {
+                                console.warn(`esbuild external-globals plugin: failed to parse exports for global import`, e);
+                                serenityModuleContents = null;
+                                // continue with commonjs export
+                            }
+                        }
+
+                        if (serenityModuleContents) {
+                            return {
+                                contents: serenityModuleContents,
+                                loader: "js"
+                            };
+                        }
+                    }
+
                     return { contents: `module.exports = ${args.path};`, loader: "js" };
                 }
             );

package/package.json

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