fix: Improve type-leaks test

eslint.config.js

@@ -52,7 +52,7 @@ export default [
                     max: 1
                 }
             ],
-            "no-console": [1, {
+            "no-console": ["error", {
                 "allow": ["info", "warn", "error"]
             }],
             "func-call-spacing": ["error", "never"],

package.json

@@ -35,6 +35,7 @@
     "update-major": "run-p update-major-workspaces update-major root"
   },
   "devDependencies": {
+    "@types/esbuild-copy-static-files": "0.1.4",
     "@typescript-eslint/eslint-plugin": "8.29.0",
     "@typescript-eslint/parser": "8.29.0",
     "@vitest/browser": "3.2.4",

packages/comms/esbuild.js

@@ -2,6 +2,6 @@ import { nodeTpl, nodeBoth } from "@hpcc-js/esbuild-plugins";
 
 //  config  ---
 await Promise.all([
-    nodeBoth("src/index.node.ts", "dist/node/index"),
+    nodeBoth("src/index.node.ts", "dist/node/index", { packages: "bundle" }),
     nodeTpl("utils/index.ts", "lib-esm/index")
 ]);

packages/comms/src/clienttools/eclMeta.ts

@@ -1,5 +1,5 @@
-import * as fs from "fs";
-import * as path from "path";
+import * as fs from "node:fs";
+import * as path from "node:path";
 
 import { Dictionary, DictionaryNoCase, find, SAXStackParser, scopedLogger, XMLNode } from "@hpcc-js/util";
 import { ClientTools, locateClientTools } from "./eclcc.ts";

packages/comms/src/clienttools/eclcc.ts

@@ -1,7 +1,7 @@
-import * as cp from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
+import * as cp from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import * as tmp from "tmp";
 
 import { exists, scopedLogger, xml2json, XMLNode } from "@hpcc-js/util";

packages/comms/src/ecl/scope.ts

@@ -1,11 +1,7 @@
 import { StateObject, StringAnyMap } from "@hpcc-js/util";
-// import { utcFormat, utcParse } from "d3-time-format";
 import { WsWorkunits } from "../services/wsWorkunits.ts";
 import { Workunit } from "./workunit.ts";
 
-// const formatter = utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");
-// const parser = utcParse("%Y-%m-%dT%H:%M:%S.%LZ");
-
 export interface AttributeEx extends WsWorkunits.Property {
     FormattedEnd?: string;
 }

packages/comms/src/index.node.ts

@@ -6,7 +6,7 @@ root.DOMParser = DOMParser;
 //  fetch polyfill  ---
 import fetch, { Headers, Request, Response, } from "node-fetch";
 
-import * as https from "https";
+import * as https from "node:https";
 import { Agent, setGlobalDispatcher } from "undici";
 
 if (typeof root.fetch === "undefined") {

packages/esbuild-plugins/src/build.ts

@@ -4,19 +4,21 @@ import * as path from "path";
 import * as esbuild from "esbuild";
 import type { BuildOptions, Format, Loader, Plugin } from "esbuild";
 import { umdWrapper } from "esbuild-plugin-umd-wrapper";
+import * as copyStaticFiles from "esbuild-copy-static-files";
 import { inlineCSS } from "./inline-css.ts";
 import { rebuildLogger } from "./rebuild-logger.ts";
 
-//@ts-ignore
-import _copyStaticFiles from "esbuild-copy-static-files";
-export const copyStaticFiles: Plugin = _copyStaticFiles;
+export { copyStaticFiles };
 
 export const pkg = JSON.parse(readFileSync(path.join(process.cwd(), "./package.json"), "utf8"));
 export const NODE_MJS = pkg.type === "module" ? "js" : "mjs";
 export const NODE_CJS = pkg.type === "module" ? "cjs" : "js";
 
-export async function buildWatch(input: string, format: Format | "umd" = "esm", external: string[] = [], config: BuildOptions, isDevelopment: boolean = process.argv.includes("--development"), isWatch: boolean = process.argv.includes("--watch")): Promise<void> {
+export async function buildWatch(inputs: string[] | Record<string, string> | { in: string, out: string }[], config: BuildOptions): Promise<void> {
+    const isDevelopment = process.argv.includes("--development");
+    const isWatch = process.argv.includes("--watch");
     const isProduction = !isDevelopment;
+
     if (isProduction && existsSync(path.join(process.cwd(), "../../package.json"))) {
         const rootPkg = JSON.parse(readFileSync(path.join(process.cwd(), "../../package.json"), "utf8"));
         writeFileSync(path.join(process.cwd(), "src/__package__.ts"), `\
@@ -26,20 +28,38 @@ export const BUILD_VERSION = "${rootPkg.version}";
 `, "utf8");
     }
 
-    const ctx = await esbuild.context({
-        entryPoints: [input],
-        format: format as Format,
+    config = {
+        entryPoints: inputs,
+        format: "esm",
         bundle: true,
         minify: isProduction,
         sourcemap: true,
-        external,
+        external: [
+            ...config.external ?? []
+        ],
         ...config,
+        loader: {
+            ...config.loader
+        },
+        outExtension: {
+            ...config.outExtension
+        },
+        banner: {
+            ...config.banner
+        },
+        footer: {
+            ...config.footer
+        },
         plugins: [
             ...(isWatch ? [rebuildLogger(config)] : []),
-            ...(config.plugins ?? []),
+            ...config.plugins ?? [],
             inlineCSS()
+        ],
+        nodePaths: [
+            ...config.nodePaths ?? []
         ]
-    });
+    };
+    const ctx = await esbuild.context(config);
 
     if (isWatch) {
         await ctx.watch();
@@ -68,35 +88,54 @@ export type TplOptions = {
     supported?: Record<string, boolean>;
     alias?: Record<string, string>;
     define?: { [key: string]: string };
+    packages?: "bundle" | "external" | "auto";
 };
 
-export function browserTpl(input: string, output: string, { format = "esm", globalName, libraryName, keepNames, external = [], plugins = [], alias = {}, define = {}, loader = {} }: TplOptions = {}) {
-    return buildWatch(input, format, external, {
-        outfile: `${output}.${format === "esm" ? "js" : `${format}.js`}`,
+function autoExternal(external?: string[]): string[] {
+    return [
+        ...pkg.dependencies ? Object.keys(pkg.dependencies) : [], ...pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : [],
+        ...external ?? []
+    ];
+}
+
+export function browserTpl(input: string, output: string, options: TplOptions = {}) {
+    options.format = options.format ?? "esm";
+
+    return buildWatch([input], {
+        format: options.format === "umd" ? "esm" : options.format,
+        external: options.external ?? [],
+        outfile: `${output}.${options.format === "esm" ? "js" : `${options.format}.js`}`,
         platform: "browser",
         target: "es2022",
-        globalName,
-        keepNames,
-        plugins: format === "umd" ? [umdWrapper({ libraryName }), ...plugins] : [...plugins],
-        alias,
-        define,
-        loader
-    } as BuildOptions);
+        globalName: options.globalName,
+        keepNames: options.keepNames,
+        plugins: options.format === "umd" ? [umdWrapper({ libraryName: options.libraryName }), ...options.plugins ?? []] : [...options.plugins ?? []],
+        alias: options.alias,
+        define: options.define,
+        loader: options.loader,
+    });
 }
 
-export function nodeTpl(input: string, output: string, { format = "esm", external = [], supported = {} }: TplOptions = {}) {
-    return buildWatch(input, format, external, {
-        outfile: `${output}.${format === "esm" ? NODE_MJS : NODE_CJS}`,
+export function nodeTpl(input: string, output: string, options: TplOptions = {}) {
+    options.packages = options.packages ?? "external";
+    if (options.packages === "auto") {
+        options.external = autoExternal(options.external);
+    }
+
+    return buildWatch([input], {
+        format: options.format === "umd" ? "esm" : options.format,
+        outfile: `${output}.${options.format === "esm" ? NODE_MJS : NODE_CJS}`,
         platform: "node",
-        target: "node20",
-        packages: "external",
-        supported
+        target: "node22",
+        packages: options.packages === "auto" ? "bundle" : options.packages,
     });
 }
 
-export function neutralTpl(input: string, output: string, { format = "esm", globalName, libraryName, keepNames, external = [] }: TplOptions = {}) {
+export function neutralTpl(input: string, output: string, options: TplOptions = {}) {
+    options.format = options.format ?? "esm";
+
     let postfix = "";
-    switch (format) {
+    switch (options.format) {
         case "iife":
             postfix = "iife.js";
             break;
@@ -110,35 +149,36 @@ export function neutralTpl(input: string, output: string, { format = "esm", glob
             postfix = "umd.js";
             break;
         default:
-            throw new Error(`Unknown format: ${format}`);
+            throw new Error(`Unknown format: ${options.format}`);
     }
-    return buildWatch(input, format, external, {
-        outfile: `${output}.${format === "esm" ? "js" : `${format}.js`}`,
+    return buildWatch([input], {
+        format: options.format === "umd" ? "esm" : options.format,
+        outfile: `${output}.${options.format === "esm" ? "js" : `${options.format}.js`}`,
         platform: "neutral",
         target: "es2022",
-        globalName,
-        keepNames,
-        plugins: format === "umd" ? [umdWrapper({ libraryName })] : [] as Plugin[]
-    } as BuildOptions);
+        globalName: options.globalName,
+        keepNames: options.keepNames,
+        plugins: options.format === "umd" ? [umdWrapper({ libraryName: options.libraryName })] : [] as Plugin[]
+    });
 }
 
-export function browserBoth(input: string, output: string, globalName?: string, libraryName?: string, external: string[] = []) {
+export function browserBoth(input: string, output: string, options: TplOptions = {}) {
     return Promise.all([
-        browserTpl(input, output, { format: "esm", globalName, libraryName, external }),
-        browserTpl(input, output, { format: "umd", globalName, libraryName, external })
+        browserTpl(input, output, { format: "esm", ...options }),
+        browserTpl(input, output, { format: "umd", ...options })
     ]);
 }
 
-export function nodeBoth(input: string, output: string, external: string[] = []) {
+export function nodeBoth(input: string, output: string, options: TplOptions = {}) {
     return Promise.all([
-        nodeTpl(input, output, { format: "esm", external }),
-        nodeTpl(input, output, { format: "cjs", external })
+        nodeTpl(input, output, { format: "esm", ...options }),
+        nodeTpl(input, output, { format: "cjs", ...options })
     ]);
 }
 
-export function bothTpl(input: string, output: string, globalName?: string, libraryName?: string, external: string[] = []) {
+export function bothTpl(input: string, output: string, options: TplOptions = {}) {
     return Promise.all([
-        browserBoth(input, output, globalName, libraryName, external),
-        nodeTpl(input, output, { format: "cjs", external })
+        browserBoth(input, output, { ...options }),
+        nodeTpl(input, output, { format: "cjs", ...options })
     ]);
 }

packages/markdown-it-plugins/esbuild.js

@@ -1,7 +1,21 @@
 import { nodeTpl } from "@hpcc-js/esbuild-plugins";
+import pkg from "./package.json" with { type: "json" };
 
 //  config  ---
 await Promise.all([
-    nodeTpl("src/loader.ts", "dist/loader.node", { supported: { "dynamic-import": true } }),
-    nodeTpl("src/ecl-lang/index.ts", "dist/ecl-lang"),
+    nodeTpl("src/loader.ts", "dist/loader.node", {
+        packages: "bundle",
+        supported: { "dynamic-import": true },
+        external: [
+            ...Object.keys(pkg.dependencies || {}),
+            ...Object.keys(pkg.peerDependencies || {})
+        ]
+    }),
+    nodeTpl("src/ecl-lang/index.ts", "dist/ecl-lang", {
+        packages: "bundle",
+        external: [
+            ...Object.keys(pkg.dependencies || {}),
+            ...Object.keys(pkg.peerDependencies || {})
+        ]
+    }),
 ]);

packages/markdown-it-plugins/package.json

@@ -58,15 +58,15 @@
         "@types/markdown-it": "14.1.2"
     },
     "peerDependencies": {
-        "markdown-it": "14.1.0"
+        "apache-arrow": "19.0.1",
+        "markdown-it": "14.1.0",
+        "shiki": "2.5.0"
     },
     "devDependencies": {
         "@hpcc-js/esbuild-plugins": "^1.4.2",
-        "apache-arrow": "19.0.1",
         "d3-dsv": "3.0.1",
         "d3-fetch": "3.0.1",
         "dotenv": "16.4.7",
-        "shiki": "2.5.0",
         "tsx": "4.19.3"
     },
     "repository": {

tests/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "hpcc-js-tests",
+    "version": "1.0.0",
+    "description": "Test orchestrator for HPCC Visualization Framework - runs all test suites",
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "test": "npm run test-all",
+        "test-all": "npm run test-node-cjs && npm run test-node-esm && npm run test-browser-esm && npm run test-browser-umd && npm run test-type-leaks",
+        "test-node": "npm run test-node-cjs && npm run test-node-esm",
+        "test-browser": "npm run test-browser-esm && npm run test-browser-umd",
+        "test-node-cjs": "cd node-cjs && npm install && npm test",
+        "test-node-esm": "cd node-esm && npm install && npm test",
+        "test-browser-esm": "cd browser-esm && npm install && npm test",
+        "test-browser-umd": "cd browser-umd && npm install && npm test",
+        "test-type-leaks": "cd type-leaks && npm install && npm test",
+        "install-all": "npm run install-node && npm run install-browser && npm run install-type-leaks",
+        "install-node": "cd node-cjs && npm install && cd ../node-esm && npm install",
+        "install-browser": "cd browser-esm && npm install && cd ../browser-umd && npm install",
+        "install-type-leaks": "cd type-leaks && npm install",
+        "clean": "npm run clean-node && npm run clean-browser && npm run clean-type-leaks",
+        "clean-node": "cd node-cjs && rm -rf node_modules package-lock.json && cd ../node-esm && rm -rf node_modules package-lock.json",
+        "clean-browser": "cd browser-esm && rm -rf node_modules package-lock.json && cd ../browser-umd && rm -rf node_modules package-lock.json",
+        "clean-type-leaks": "cd type-leaks && rm -rf node_modules package-lock.json"
+    }
+}