quickbundle 0.15.0 → 1.0.0

package/README.md

@@ -12,11 +12,11 @@ Quickbundle allows you to bundle a library in a **quick**, **fast** and **easy**
 
 -   Fast build and watch mode thanks to [esbuild](https://esbuild.github.io/)
 -   Zero configuration: define the build artifacts in your `package.json` and you're all set!
--   JavaScript, TypeScript, JSX, CSS, JSON, Image and Text support following [esbuild support](https://esbuild.github.io/content-types/)
 -   Support of multiple module formats including `cjs` & `esm`
+-   JavaScript, TypeScript, JSX, CSS, JSON, Image and Text support following [esbuild support](https://esbuild.github.io/content-types/)
+-   TypeScript declaration file (`.d.ts`) generation with bundling support
 -   Bundling can be done for several platform targets including `browser` or `node`
--   Optimized build such as `peerDependencies` not bundled in the final output
--   Serve and live reload support for `html` entrypoint
+-   Optimized build with automatic dependency inclusion (`peerDependencies` and `dependencies` are not bundled in the final output whatever the defined platform target)
 
 <br>
 
@@ -25,8 +25,10 @@ Quickbundle allows you to bundle a library in a **quick**, **fast** and **easy**
 1️⃣ Install by running:
 
 ```bash
-# NPM
+# Npm
 npm install quickbundle
+# Pnpm
+pnpm add quickbundle
 # Yarn
 yarn add quickbundle
 ```
@@ -37,16 +39,13 @@ yarn add quickbundle
 {
 	"name": "lib", // Package name
 	"source": "src/index.ts", // Source code entrypoint
-	"main": "./dist/lib.cjs", // CommonJS output file
-	"module": "./dist/lib.cjs.js", // ESM output file
-	"types": "./dist/lib.d.ts", // Typing output file
+	"main": "./dist/index.cjs", // CommonJS output file
+	"module": "./dist/index.mjs", // ESM output file
+	"types": "./dist/index.d.ts", // Typing output file (if defined, can increase build time)
 	"platform": "node", // Platform target (optional, by default "browser")
 	"scripts": {
 		"build": "quickbundle build", // Production mode (optimizes bundle)
 		"watch": "quickbundle watch", // Development mode (watches each file change)
-		"serve": "quickbundle watch --serve public/index.html", // Serve an html entrypoint with live reload capabilities (for more details, check examples folder)
-		"build:fast": "quickbundle build --no-check", // Production mode with fast transpilation time. This mode disables TypeScript type checking (ie. not using `tsc`) and, consequently, the `types` asset is no more managed by the tool
-		"watch:fast": "quickbundle watch --no-check" // Development mode with fast transpilation time
 	}
 }
 ```
@@ -54,10 +53,12 @@ yarn add quickbundle
 3️⃣ Try it by running:
 
 ```bash
-# NPM
-npm run prod
+# Npm
+npm run build
+# Pnpm
+pnpm build
 # Yarn
-yarn prod
+yarn build
 ```
 
 <br>
@@ -72,7 +73,7 @@ Contribution welcomed! 🤗
 
 ## 💙 Acknowledgements
 
--   The backend powered by [ESBuild](https://github.com/evanw/esbuild) to make blazing fast builds. A special shoutout to its author [Evan Wallace](https://github.com/evanw) and [all contributors](https://github.com/evanw/esbuild/graphs/contributors).
+-   The backend is powered by [ESBuild](https://github.com/evanw/esbuild) to make blazing-fast builds. A special shoutout to its author [Evan Wallace](https://github.com/evanw) and [all contributors](https://github.com/evanw/esbuild/graphs/contributors).
 -   The zero-configuration approach was inspired by [microbundle](https://github.com/developit/microbundle). A special shoutout to its author [Jason Miller](https://github.com/developit) and [all contributors](https://github.com/developit/microbundle/graphs/contributors).
 
 <br>

package/bin/bundler/bundler.d.ts

@@ -1,8 +1,2 @@
-declare type BundleParameters = {
-    isProduction: boolean;
-    isFast: boolean;
-    onWatch?: (error: Error | null) => void;
-    serveEntryPoint?: string;
-};
-export declare const bundle: ({ isProduction, isFast, onWatch, serveEntryPoint, }: BundleParameters) => Promise<(string | null)[]>;
-export {};
+export declare const build: () => Promise<any[]>;
+export declare const watch: (onWatch: (type: "loading" | "result", error?: string) => void) => Promise<void>;

package/bin/bundler/bundler.js

@@ -1,97 +1,88 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundle = void 0;
+exports.watch = exports.build = void 0;
 const esbuild_1 = require("esbuild");
-const http_1 = require("http");
-const constants_1 = require("../constants");
+const threads_1 = require("threads");
 const helpers_1 = require("../helpers");
-const package_1 = require("./package");
-const plugins_1 = require("./plugins");
-const typescript_1 = require("./typescript");
-const bundle = ({ isProduction, isFast, onWatch, serveEntryPoint, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { destination, externalDependencies, hasModule, platform, source, types, } = (0, package_1.getPackageMetadata)();
-    const isWatching = typeof onWatch === "function";
-    const isLiveReloadable = serveEntryPoint && isWatching;
-    const isTypingRequested = typeof types === "string" && !isFast;
-    const tsConfig = yield (0, typescript_1.getTypeScriptConfiguration)();
-    const getType = () => __awaiter(void 0, void 0, void 0, function* () {
-        const outfile = types;
-        if (!outfile)
-            return null;
-        yield (0, typescript_1.generateTypeScriptDeclaration)(outfile);
-        return outfile;
+const configs_1 = require("./configs");
+const build = async () => {
+    const { pkg, typescript } = await (0, configs_1.getConfigs)({
+        isProduction: true,
     });
-    const getJavaScript = (format) => __awaiter(void 0, void 0, void 0, function* () {
-        const outfile = destination[format];
-        if (!outfile)
-            return null;
-        yield (0, esbuild_1.build)(Object.assign(Object.assign({}, (isLiveReloadable && {
-            banner: {
-                js: `;new EventSource("http://0.0.0.0:${servePort}").onmessage = function() { location.reload(); }; console.log("Live reload ✅ (port: ${servePort})");`,
-            },
-        })), { absWorkingDir: constants_1.CWD, bundle: true, define: {
-                "process.env.NODE_ENV": isProduction
-                    ? '"production"'
-                    : '"development"',
-            }, entryPoints: [source], external: externalDependencies, format, loader: {
-                ".jpg": "file",
-                ".jpeg": "file",
-                ".png": "file",
-                ".gif": "file",
-                ".svg": "file",
-                ".webp": "file",
-            }, logLevel: "silent", metafile: true, minify: isProduction, outfile, plugins: [(0, plugins_1.jsxPlugin)(tsConfig)], platform, sourcemap: true, target: (tsConfig === null || tsConfig === void 0 ? void 0 : tsConfig.target) || "esnext", treeShaking: true, watch: isWatching && {
-                onRebuild(bundleError) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let error = bundleError;
-                        if (isLiveReloadable) {
-                            clients.forEach((client) => {
-                                client.write("data: update\n\n");
+    const promises = [
+        buildJavaScript("cjs"),
+        ...(pkg.hasModule ? [buildJavaScript("esm")] : []),
+        ...(typescript.isEnabled
+            ? [
+                buildDts({
+                    source: pkg.source,
+                    destination: pkg.types,
+                }),
+            ]
+            : []),
+    ];
+    return Promise.all(promises);
+};
+exports.build = build;
+const watch = async (onWatch) => {
+    const { esbuild, pkg, typescript } = await (0, configs_1.getConfigs)({
+        isProduction: false,
+    });
+    const ctx = await (0, esbuild_1.context)({
+        ...esbuild({ format: "cjs", outfile: pkg.destination["cjs"] }),
+        plugins: [
+            {
+                name: "onBuildEnd",
+                setup(build) {
+                    build.onStart(() => {
+                        onWatch("loading");
+                    });
+                    build.onEnd(async (result) => {
+                        const error = (await (0, esbuild_1.formatMessages)(result.errors, {
+                            kind: "error",
+                            color: true,
+                            terminalWidth: 100,
+                        })).join("\n");
+                        // If there's already a build error, no need to run
+                        // a heavy typing generation process until the error is fixed
+                        if (!error && typescript.isEnabled) {
+                            buildDts({
+                                source: pkg.source,
+                                destination: pkg.types,
+                            })
+                                .then(() => {
+                                onWatch("result");
+                            })
+                                .catch((err) => {
+                                onWatch("result", err);
                             });
-                            clients = [];
                         }
-                        if (!error && isTypingRequested) {
-                            try {
-                                yield getType();
-                            }
-                            catch (typingError) {
-                                error = typingError;
-                            }
+                        else {
+                            onWatch("result", error);
                         }
-                        onWatch(error);
                     });
                 },
-            } }));
-        return outfile;
+            },
+        ],
     });
-    if (isLiveReloadable) {
-        servePort = yield (0, helpers_1.getAvailablePortFrom)(servePort);
-        (0, http_1.createServer)((_, res) => {
-            clients.push(res.writeHead(200, {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                "Access-Control-Allow-Origin": "*",
-            }));
-        }).listen(servePort);
-        (0, helpers_1.openBrowser)(serveEntryPoint);
+    await ctx.watch();
+};
+exports.watch = watch;
+const buildJavaScript = async (format) => {
+    const worker = await (0, threads_1.spawn)(new threads_1.Worker("./workers/esbuild"));
+    const outfile = await worker(format);
+    await threads_1.Thread.terminate(worker);
+    return outfile;
+};
+const buildDts = async ({ source, destination, }) => {
+    try {
+        const worker = await (0, threads_1.spawn)(new threads_1.Worker("./workers/dts"));
+        const dtsContent = await worker(source);
+        await (0, helpers_1.writeFile)(destination, dtsContent);
+        await threads_1.Thread.terminate(worker);
+        return destination;
     }
-    const promises = [
-        ...(isWatching
-            ? [getJavaScript(hasModule ? "esm" : "cjs")]
-            : [getJavaScript("cjs"), getJavaScript("esm")]),
-        ...(isTypingRequested ? [getType()] : []),
-    ];
-    return Promise.all(promises);
-});
-exports.bundle = bundle;
-let clients = [];
-let servePort = 9000;
+    catch (error) {
+        throw new Error(`Type generation failed:\n${error}`);
+    }
+};

package/bin/bundler/configs/esbuild.d.ts

@@ -0,0 +1,8 @@
+import type { BuildOptions } from "esbuild";
+import type { TSConfig } from "./typescript";
+export interface EsbuildConfig extends Required<Pick<BuildOptions, "format" | "outfile" | "external" | "platform">> {
+    isProduction: boolean;
+    source: string;
+    tsConfig: TSConfig | null;
+}
+export declare const getEsbuildConfig: ({ external, format, isProduction, outfile, platform, source, tsConfig, }: EsbuildConfig) => BuildOptions;

package/bin/bundler/configs/esbuild.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEsbuildConfig = void 0;
+const helpers_1 = require("../../helpers");
+const constants_1 = require("../../constants");
+const getEsbuildConfig = ({ external, format, isProduction, outfile, platform, source, tsConfig, }) => ({
+    absWorkingDir: constants_1.CWD,
+    bundle: true,
+    color: true,
+    define: {
+        "process.env.NODE_ENV": isProduction ? '"production"' : '"development"',
+    },
+    entryPoints: [source],
+    external,
+    format,
+    loader: {
+        ".jpg": "file",
+        ".jpeg": "file",
+        ".png": "file",
+        ".gif": "file",
+        ".svg": "file",
+        ".webp": "file",
+    },
+    logLevel: "silent",
+    metafile: true,
+    minify: isProduction,
+    outfile,
+    plugins: [jsxPlugin(tsConfig)],
+    platform,
+    sourcemap: true,
+    target: tsConfig?.target || "esnext",
+    treeShaking: true,
+});
+exports.getEsbuildConfig = getEsbuildConfig;
+/**
+ * Plugin to automatically inject React import for jsx management
+ * ESBuild doesn't support `jsx` tsconfig field: this plugin aims to add a tiny wrapper to support it
+ * We could use the `inject` ESBuild feature but it will break the tree shaking behavior since the React import will
+ * be imported on each file (even in .ts file) leading React being included in the bundle even if not needed
+ * @see: https://github.com/evanw/esbuild/issues/334
+ * @param tsConfig
+ * @returns Plugin
+ */
+const jsxPlugin = (tsConfig) => ({
+    name: "jsx-runtime",
+    setup(build) {
+        build.onLoad({ filter: /\.(j|t)sx$/ }, async ({ path }) => {
+            // Enable plugin only if
+            // - `${module}/jsx-runtime` package is available (for js project, it's the only condition to check!)
+            // - if ts project: jsx compilerOption === "react-jsx" or "react-jsxdev"
+            if (!tsConfig || !tsConfig.hasJsxRuntime)
+                return;
+            const module = tsConfig.jsxImportSource || "react";
+            if (!(0, helpers_1.resolveModulePath)(`${module}/jsx-runtime`)) {
+                throw new Error("Unable to find the JSX runtime.\nPotential solutions:\n1. If you rely on a non React runtime, set a valid `jsxImportSource` in your tsconfig\n2. Make sure that you've installed your project dependencies");
+            }
+            const content = await (0, helpers_1.readFile)(path, "utf8");
+            return {
+                contents: `import * as React from "${module}";${content}`,
+                loader: "tsx",
+            };
+        });
+    },
+});

package/bin/bundler/configs/index.d.ts

@@ -0,0 +1,22 @@
+import { BuildOptions } from "esbuild";
+import { EsbuildConfig } from "./esbuild";
+type ConfigOptions = {
+    isProduction: boolean;
+};
+export declare const getConfigs: ({ isProduction }: ConfigOptions) => Promise<{
+    esbuild: ({ format, outfile, }: Pick<EsbuildConfig, "format" | "outfile">) => BuildOptions;
+    pkg: {
+        destination: {
+            readonly esm?: string;
+            readonly cjs: string;
+        };
+        hasModule: boolean;
+        source: string;
+        types: string | undefined;
+    };
+    typescript: {
+        configuration: import("./typescript").TSConfig | null;
+        isEnabled: boolean;
+    };
+}>;
+export {};

package/bin/bundler/configs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigs = void 0;
+const esbuild_1 = require("./esbuild");
+const package_1 = require("./package");
+const typescript_1 = require("./typescript");
+const getConfigs = async ({ isProduction }) => {
+    const { destination, externalDependencies, hasModule, platform, source, types, } = (0, package_1.getPkgConfig)();
+    const tsConfig = await (0, typescript_1.getTSConfig)();
+    const hasTyping = typeof types === "string" && Boolean(tsConfig);
+    const esbuild = ({ format, outfile, }) => (0, esbuild_1.getEsbuildConfig)({
+        external: externalDependencies,
+        format,
+        isProduction,
+        outfile,
+        platform,
+        source,
+        tsConfig,
+    });
+    return {
+        esbuild,
+        pkg: {
+            destination,
+            hasModule,
+            source,
+            types,
+        },
+        typescript: {
+            configuration: tsConfig,
+            isEnabled: hasTyping,
+        },
+    };
+};
+exports.getConfigs = getConfigs;

package/bin/bundler/{package.d.ts → configs/package.d.ts}

@@ -1,6 +1,6 @@
-export declare const getPackageMetadata: () => {
+export declare const getPkgConfig: () => {
     readonly destination: {
-        readonly esm?: string | undefined;
+        readonly esm?: string;
         readonly cjs: string;
     };
     readonly externalDependencies: string[];

package/bin/bundler/{package.js → configs/package.js}

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageMetadata = void 0;
+exports.getPkgConfig = void 0;
+/* eslint-disable @typescript-eslint/no-var-requires */
 const path_1 = require("path");
-const constants_1 = require("../constants");
-const helpers_1 = require("../helpers");
-const getPackageMetadata = () => {
+const constants_1 = require("../../constants");
+const helpers_1 = require("../../helpers");
+const getPkgConfig = () => {
     const { devDependencies = {}, peerDependencies = {}, dependencies = {}, main, module, platform = "browser", source, types, } = require((0, path_1.resolve)(constants_1.CWD, "package.json"));
     (0, helpers_1.assert)(main, "A `main` field is required in `package.json`. Did you forget to add it?");
     (0, helpers_1.assert)(source, "A `source` field is required in `package.json`. Did you forget to add it?");
     (0, helpers_1.assert)(["browser", "node"].includes(platform), "The `platform` package field can only accept `browser` or `node` value.");
-    const peerDependencyNames = Object.keys(peerDependencies);
+    const isomorphicExternalDependencies = [
+        ...Object.keys(peerDependencies),
+        ...Object.keys(dependencies),
+    ];
     const externalDependencies = platform === "browser"
-        ? peerDependencyNames
+        ? isomorphicExternalDependencies
         : [
-            ...peerDependencyNames,
-            ...Object.keys(dependencies),
+            ...isomorphicExternalDependencies,
             ...Object.keys(devDependencies),
         ];
     return {
-        destination: Object.assign({ cjs: main }, (module && { esm: module })),
+        destination: {
+            cjs: main,
+            ...(module && { esm: module }),
+        },
         externalDependencies,
         hasModule: Boolean(module),
         platform,
@@ -26,4 +32,4 @@ const getPackageMetadata = () => {
         types,
     };
 };
-exports.getPackageMetadata = getPackageMetadata;
+exports.getPkgConfig = getPkgConfig;

package/bin/bundler/configs/typescript.d.ts

@@ -0,0 +1,6 @@
+export type TSConfig = {
+    target: string;
+    jsxImportSource: string | undefined;
+    hasJsxRuntime: boolean;
+};
+export declare const getTSConfig: () => Promise<TSConfig | null>;

package/bin/bundler/configs/typescript.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTSConfig = void 0;
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("typescript"));
+const constants_1 = require("../../constants");
+const TSCONFIG_PATH = (0, path_1.resolve)(constants_1.CWD, "tsconfig.json");
+const getTSConfig = async () => {
+    try {
+        const { jsx, jsxImportSource, target } = typescript_1.default.parseJsonConfigFileContent(
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require(TSCONFIG_PATH), typescript_1.default.sys, constants_1.CWD).options;
+        // Convert ts target value to esbuild ones (latest value is not supported)
+        const esbuildTarget = !target ||
+            [typescript_1.default.ScriptTarget.ESNext, typescript_1.default.ScriptTarget.Latest].includes(target)
+            ? "esnext"
+            : typescript_1.default.ScriptTarget[target]?.toLowerCase();
+        const hasJsxRuntime = jsx !== undefined &&
+            [typescript_1.default.JsxEmit["ReactJSX"], typescript_1.default.JsxEmit["ReactJSXDev"]].includes(jsx);
+        return {
+            target: esbuildTarget,
+            jsxImportSource,
+            hasJsxRuntime,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+};
+exports.getTSConfig = getTSConfig;

package/bin/bundler/index.d.ts

@@ -1 +1 @@
-export { bundle } from "./bundler";
+export { build, watch } from "./bundler";

package/bin/bundler/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundle = void 0;
+exports.watch = exports.build = void 0;
 var bundler_1 = require("./bundler");
-Object.defineProperty(exports, "bundle", { enumerable: true, get: function () { return bundler_1.bundle; } });
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return bundler_1.build; } });
+Object.defineProperty(exports, "watch", { enumerable: true, get: function () { return bundler_1.watch; } });

package/bin/bundler/workers/dts.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/bundler/workers/dts.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dts_bundle_generator_1 = require("dts-bundle-generator");
+const worker_1 = require("threads/worker");
+(0, worker_1.expose)((source) => {
+    const errors = [];
+    // To prevent any UI glitch, catch any error by monkey patching
+    // the default error logger and forward them to the parent worker
+    console.error = (error) => {
+        errors.push(error);
+    };
+    try {
+        return (0, dts_bundle_generator_1.generateDtsBundle)([
+            {
+                filePath: source,
+                output: {
+                    noBanner: true,
+                },
+            },
+        ])[0];
+    }
+    catch {
+        throw errors;
+    }
+});

package/bin/bundler/workers/esbuild.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/bundler/workers/esbuild.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const esbuild_1 = require("esbuild");
+const worker_1 = require("threads/worker");
+const configs_1 = require("../configs");
+(0, worker_1.expose)(async (format) => {
+    const { esbuild, pkg } = await (0, configs_1.getConfigs)({
+        isProduction: true,
+    });
+    const outfile = pkg.destination[format];
+    if (!outfile)
+        return null;
+    await (0, esbuild_1.build)(esbuild({ format, outfile }));
+    return outfile;
+});

package/bin/helpers.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import { readFile as fsReadFile } from "fs";
-export declare const readFile: typeof fsReadFile.__promisify__;
-export declare const resolveModulePath: (path: string) => boolean;
+import fs from "node:fs/promises";
 export declare function assert(condition: unknown, message: string): asserts condition;
-export declare const getAvailablePortFrom: (port: number) => Promise<number>;
-export declare const openBrowser: (filename: string) => void;
+export declare const readFile: typeof fs.readFile;
+export declare const resolveModulePath: (path: string) => boolean;
+export declare const writeFile: (filePath: string, content: string) => Promise<void>;

package/bin/helpers.js

@@ -1,21 +1,22 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openBrowser = exports.getAvailablePortFrom = exports.assert = exports.resolveModulePath = exports.readFile = void 0;
-const util_1 = require("util");
-const fs_1 = require("fs");
-const net_1 = require("net");
-const child_process_1 = require("child_process");
+exports.writeFile = exports.resolveModulePath = exports.readFile = exports.assert = void 0;
+const node_path_1 = require("node:path");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_fs_1 = require("node:fs");
 const constants_1 = require("./constants");
-exports.readFile = (0, util_1.promisify)(fs_1.readFile);
+// TS assertion not working properly with arrow function
+// @see: https://github.com/microsoft/TypeScript/issues/34523
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+exports.assert = assert;
+exports.readFile = promises_1.default.readFile;
 const resolveModulePath = (path) => {
     try {
         return Boolean(require.resolve(path, { paths: [constants_1.CWD] }));
@@ -25,35 +26,11 @@ const resolveModulePath = (path) => {
     }
 };
 exports.resolveModulePath = resolveModulePath;
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(message);
-    }
-}
-exports.assert = assert;
-const getAvailablePortFrom = (port) => __awaiter(void 0, void 0, void 0, function* () {
-    return new Promise((resolve) => {
-        const server = (0, net_1.createServer)();
-        server.listen(port);
-        server.on("listening", () => server.close(() => resolve(port)));
-        server.on("error", () => {
-            server.listen(++port);
-        });
-    });
-});
-exports.getAvailablePortFrom = getAvailablePortFrom;
-const openBrowser = (filename) => {
-    const bins = {
-        darwin: "open",
-        linux: "xdg-open",
-    };
-    const { platform } = process;
-    if (platform !== "darwin" && platform !== "linux") {
-        return;
-    }
-    if (!(0, fs_1.existsSync)(filename)) {
-        throw new Error(`Unable to find ${filename}.\nPotential solutions:\n1. Create the missing file\n2. Edit the serve entrypoint to match an existing html file`);
+const writeFile = async (filePath, content) => {
+    const dir = (0, node_path_1.dirname)(filePath);
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        await promises_1.default.mkdir(dir, { recursive: true });
     }
-    (0, child_process_1.spawn)(bins[platform], [filename]);
+    await promises_1.default.writeFile(filePath, content, "utf8");
 };
-exports.openBrowser = openBrowser;
+exports.writeFile = writeFile;