@hpcc-js/esbuild-plugins 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hpcc-js/esbuild-plugins",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Various esbuild plugins",
   "type": "module",
   "exports": {
@@ -17,13 +17,14 @@
   "types": "./types/index.d.ts",
   "files": [
     "dist/**/*",
+    "src/**/*",
     "types/**/*"
   ],
   "scripts": {
     "clean": "rimraf ./dist ./types",
     "build-types": "tsc --project tsconfig.json --emitDeclarationOnly",
     "build-types-watch": "npm run build-types -- --watch",
-    "build-ts-dev": "esbuild ./src/index.ts --platform=node --format=esm --bundle --packages=external --sourcemap --outfile=./dist/index.js",
+    "build-ts-dev": "esbuild ./src/index.ts --platform=node --format=esm --bundle --sourcemap --outfile=./dist/index.js",
     "build-ts": "npm run build-ts-dev -- --minify",
     "build-ts-watch": "npm run build-ts-dev -- --watch",
     "build-dev": "run-p build-types build-ts-dev",

package/src/build.ts

@@ -0,0 +1,140 @@
+import * as process from "process";
+import { readFileSync } from "fs";
+import * as path from "path";
+import * as esbuild from "esbuild";
+import type { BuildOptions, Format } from "esbuild";
+import { umdWrapper } from "esbuild-plugin-umd-wrapper";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { rebuildLogger } from "./rebuild-logger.ts";
+import { sfxWasm } from "./sfx-wrapper.ts";
+
+const pkg = JSON.parse(readFileSync(path.join(process.cwd(), "./package.json"), "utf8"));
+const NODE_MJS = pkg.type === "module" ? "js" : "mjs";
+const NODE_CJS = pkg.type === "module" ? "cjs" : "js";
+
+const myYargs = yargs(hideBin(process.argv));
+myYargs
+    .usage("Usage: node esbuild.mjs [options]")
+    .demandCommand(0, 0)
+    .example("node esbuild.mjs --watch", "Bundle and watch for changes")
+    .option("mode", {
+        alias: "m",
+        describe: "Build mode",
+        choices: ["development", "production"],
+        default: "production"
+    })
+    .option("w", {
+        alias: "watch",
+        describe: "Watch for changes",
+        type: "boolean"
+    })
+    .help("h")
+    .alias("h", "help")
+    .epilog("https://github.com/hpcc-systems/hpcc-js-wasm")
+    ;
+const argv = await myYargs.argv;
+const isDevelopment = argv.mode === "development";
+const isProduction = !isDevelopment;
+const isWatch = argv.watch;
+
+export function build(config: BuildOptions) {
+    if (isDevelopment && Array.isArray(config.entryPoints)) {
+        console.log("Start:  ", config.entryPoints[0], config.outfile);
+    }
+    return esbuild.build({
+        ...config,
+        sourcemap: "linked",
+        plugins: [
+            ...(config.plugins ?? []),
+            sfxWasm()
+        ]
+    }).finally(() => {
+        if (isDevelopment && Array.isArray(config.entryPoints)) {
+            console.log("Stop:   ", config.entryPoints[0], config.outfile);
+        }
+    });
+}
+
+export async function watch(config: BuildOptions) {
+    await build(config);
+    return esbuild.context({
+        ...config,
+        sourcemap: "external",
+        plugins: [
+            ...(config.plugins ?? []),
+            rebuildLogger(config),
+            sfxWasm()
+        ]
+    }).then(ctx => {
+        return ctx.watch();
+    });
+}
+
+export function buildWatch(config: BuildOptions) {
+    return isWatch ? watch(config) : build(config);
+}
+
+export function browserTpl(input: string, output: string, format: Format | "umd" = "esm", globalName?: string, external: string[] = []) {
+    return buildWatch({
+        entryPoints: [input],
+        outfile: `${output}.${format === "esm" ? "js" : "umd.js"}`,
+        platform: "browser",
+        target: "es2022",
+        format: format as Format,
+        globalName,
+        bundle: true,
+        minify: isProduction,
+        external,
+        plugins: format === "umd" ? [umdWrapper()] : []
+    });
+}
+
+export function browserBoth(input: string, output: string, globalName?: string, external: string[] = []) {
+    return Promise.all([
+        browserTpl(input, output, "esm", globalName, external),
+        browserTpl(input, output, "umd", globalName, external)
+    ]);
+}
+
+export function nodeTpl(input: string, output: string, format: Format | "umd" = "esm", external: string[] = []) {
+    return buildWatch({
+        entryPoints: [input],
+        outfile: `${output}.${format === "esm" ? NODE_MJS : NODE_CJS}`,
+        platform: "node",
+        target: "node20",
+        format: format as Format,
+        bundle: true,
+        minify: isProduction,
+        external
+    });
+}
+
+export function neutralTpl(input: string, output: string, format: Format | "umd" = "esm", globalName?: string, external: string[] = []) {
+    return buildWatch({
+        entryPoints: [input],
+        outfile: `${output}.${format === "esm" ? "js" : "umd.js"}`,
+        platform: "neutral",
+        target: "es2022",
+        format: format as Format,
+        globalName,
+        bundle: true,
+        minify: isProduction,
+        external,
+        plugins: format === "umd" ? [umdWrapper()] : []
+    });
+}
+
+export function nodeBoth(input: string, output: string, external: string[] = []) {
+    return Promise.all([
+        nodeTpl(input, output, "esm", external),
+        nodeTpl(input, output, "cjs", external)
+    ]);
+}
+
+export function bothTpl(input: string, output: string, globalName?: string, external: string[] = []) {
+    return Promise.all([
+        browserBoth(input, output, globalName, external),
+        nodeTpl(input, output, "cjs", external)
+    ]);
+}

package/src/exclude-sourcemap.ts

@@ -0,0 +1,20 @@
+import { readFile } from "fs/promises";
+import type { PluginBuild, Plugin } from "esbuild";
+
+export interface ExcludeSourcemapOptions {
+    filter: RegExp;
+}
+export function excludeSourcemap(opts: ExcludeSourcemapOptions): Plugin {
+    return {
+        name: "exclude-sourcemap",
+
+        setup(build: PluginBuild) {
+            build.onLoad({ filter: opts.filter }, async args => {
+                return {
+                    contents: await readFile(args.path, "utf8") + "\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIiJdLCJtYXBwaW5ncyI6IkEifQ==",
+                    loader: "default",
+                };
+            });
+        },
+    };
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./build.ts";
+export * from "./exclude-sourcemap.ts";
+export * from "./problem-matcher.ts";
+export * from "./rebuild-logger.ts";
+export * from "./sfx-wrapper.ts";

package/src/problem-matcher.ts

@@ -0,0 +1,22 @@
+import type { PluginBuild, Plugin } from "esbuild";
+
+export function problemMatcher(): Plugin {
+    return {
+        name: "problem-matcher",
+
+        setup(build: PluginBuild) {
+
+            build.onStart(() => {
+                console.log("[watch] build started");
+            });
+
+            build.onEnd((result) => {
+                result.errors.forEach(({ text, location }) => {
+                    console.error(`✘ [ERROR] ${text}`);
+                    console.error(`    ${location?.file}:${location?.line}:${location?.column}:`);
+                });
+                console.log("[watch] build finished");
+            });
+        }
+    };
+}

package/src/rebuild-logger.ts

@@ -0,0 +1,22 @@
+import type { PluginBuild, Plugin } from "esbuild";
+
+export interface RebuildLoggerOptions {
+    outfile?: string;
+}
+
+export function rebuildLogger(opts: RebuildLoggerOptions): Plugin {
+    return {
+        name: "rebuild-logger",
+
+        setup(build: PluginBuild) {
+
+            build.onStart(() => {
+                console.log("[watch] build started");
+            });
+
+            build.onEnd(() => {
+                console.log(`Rebuilt ${opts.outfile ?? "Unknown"}`);
+            });
+        }
+    };
+}

package/src/sfx-wrapper.ts

@@ -0,0 +1,108 @@
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { Base91 } from "@hpcc-js/wasm-base91";
+import { Zstd } from "@hpcc-js/wasm-zstd";
+import type { Plugin, PluginBuild } from "esbuild";
+
+function tpl(wasmJsPath: string, base91Wasm: string, base91CompressedWasm: string) {
+
+    const compressed = (base91CompressedWasm.length + 8 * 1024) <= base91Wasm.length;
+    const wasmJsExists = existsSync(wasmJsPath);
+
+    return `\
+${compressed ? 'import { decompress } from "fzstd";' : ''}
+${wasmJsExists ? `import wrapper from "${wasmJsPath}";` : ''}
+
+const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_\`{|}~"';
+
+function decode(raw: string): Uint8Array {
+    const len = raw.length;
+    const ret: number[] = [];
+
+    let b = 0;
+    let n = 0;
+    let v = -1;
+
+    for (let i = 0; i < len; i++) {
+        const p = table.indexOf(raw[i]);
+        /* istanbul ignore next */
+        if (p === -1) continue;
+        if (v < 0) {
+            v = p;
+        } else {
+            v += p * 91;
+            b |= v << n;
+            n += (v & 8191) > 88 ? 13 : 14;
+            do {
+                ret.push(b & 0xff);
+                b >>= 8;
+                n -= 8;
+            } while (n > 7);
+            v = -1;
+        }
+    }
+
+    if (v > -1) {
+        ret.push((b | v << n) & 0xff);
+    }
+
+    return new Uint8Array(ret);
+}
+
+const blobStr = '${compressed ? base91CompressedWasm : base91Wasm}';
+
+let g_module: Uint8Array | undefined;
+let g_wasmBinary: Uint8Array | undefined;
+export default function() {
+    if (!g_wasmBinary) {
+        g_wasmBinary = ${compressed ? "decompress(decode(blobStr))" : "decode(blobStr)"};
+    }
+${!wasmJsExists ? `\
+    return g_wasmBinary;
+`: `\
+    if (!g_module) {
+        g_module = wrapper({
+            wasmBinary: g_wasmBinary,
+            locateFile: undefined
+        });
+    }
+    return g_module;
+`}
+}
+
+export function reset() {
+    if (g_module) {
+        g_module = undefined;
+    }
+} `.trim();
+}
+
+export async function wrap(path: string) {
+    const base91 = await Base91.load();
+    const zstd = await Zstd.load();
+
+    const wasm = await readFile(path);
+    path = path.replace(/\.js$/, ".xxx");
+    const wasmJsPath = path.replace(/\.wasm$/, ".js");
+    const base91Wasm = base91.encode(wasm);
+    const compressedWasm = zstd.compress(wasm);
+    const base91CompressedWasm = base91.encode(compressedWasm);
+
+    return tpl(wasmJsPath, base91Wasm, base91CompressedWasm);
+}
+
+export function sfxWasm(): Plugin {
+    return {
+        name: "sfx-wasm",
+
+        setup(build: PluginBuild) {
+
+            build.onLoad({ filter: /\.wasm$/ }, async args => {
+                return {
+                    contents: await wrap(args.path),
+                    loader: "ts",
+                };
+            });
+        }
+    }
+};