@ublitzjs/core 1.0.0 → 1.1.0

package/dist/types/http-headers.d.ts

@@ -1,5 +1,18 @@
+import { type HttpMethods } from "./index.js";
+export declare var helmentHeaders: {
+    readonly "X-Content-Type-Options": "nosniff";
+    readonly "X-DNS-Prefetch-Control": "off";
+    readonly "X-Frame-Options": "DENY";
+    readonly "Referrer-Policy": "same-origin";
+    readonly "X-Permitted-Cross-Domain-Policies": "none";
+    readonly "X-Download-Options": "noopen";
+    readonly "Cross-Origin-Resource-Policy": "same-origin";
+    readonly "Cross-Origin-Opener-Policy": "same-origin";
+    readonly "Cross-Origin-Embedder-Policy": "require-corp";
+    readonly "Origin-Agent-Cluster": "?1";
+};
 import type { HttpResponse as uwsHttpResponse } from "uWebSockets.js";
-type helmetHeadersT = {
+export type helmetHeadersT = {
     /**
      *  By adding this header you can declare that your site should only load resources that have explicitly opted-in to being loaded across origin.
      * "require-corp" LETS YOU USE new SharedArrayBuffer()
@@ -49,7 +62,7 @@ type helmetHeadersT = {
      * */
     "X-XSS-Protection"?: string;
 };
-type CORSHeader = {
+export type CORSHeader = {
     /**
      * The HTTP Access-Control-Allow-Credentials response header tells browsers whether the server allows credentials to be included in cross-origin HTTP requests.
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Access-Control-Allow-Credentials
@@ -96,7 +109,7 @@ type CORSHeader = {
      */
     "Access-Control-Request-Method": string;
 };
-type experimentalHeaders = {
+export type experimentalHeaders = {
     /**
      * @experimental
      * The HTTP Attribution-Reporting-Eligible request header indicates that the corresponding response is eligible to register an attribution source or trigger.
@@ -350,7 +363,7 @@ type experimentalHeaders = {
      * */
     "Use-As-Dictionary": string;
 };
-type simpleHeaders = {
+export type simpleHeaders = {
     /**
      * indicates which content types, expressed as MIME types, the sender is able to understand
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept
@@ -521,7 +534,7 @@ type simpleHeaders = {
   It should only be included in 206 Partial Content or 416 Range Not Satisfiable responses.
   @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Range
      */
-    "Content-Range": string;
+    "Content-Range": `bytes ${number}-${number}/*` | `bytes ${number}-${number}/${number}` | `bytes */${number}`;
     /**
      * The HTTP Content-Security-Policy response header allows website administrators to control resources the user agent is allowed to load for a given page.
      *
@@ -544,7 +557,7 @@ type simpleHeaders = {
      * You know this one. It is "text/html" or "video/mp4" or whatever
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Type
      */
-    "Content-Type": string;
+    "Content-Type": `${string}/${string}` | `${string}/${string}; ${string}`;
     /**
      * The HTTP Cookie request header contains stored HTTP cookies associated with the server (i.e., previously sent by the server with the Set-Cookie header or set in JavaScript using Document.cookie)
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cookie
@@ -565,7 +578,7 @@ type simpleHeaders = {
      * @see
      * https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/ETag
      * */
-    Etag: string;
+    Etag: `W/"${string}"` | `"${string}"`;
     /**
      *The HTTP Expect request header indicates that there are expectations that need to be met by the server in order to handle the complete request successfully.
   
@@ -609,7 +622,7 @@ type simpleHeaders = {
      * The HTTP If-Match request header makes a request conditional. A server will return resources for GET and HEAD methods, or upload resource for PUT and other non-safe methods, only if the resource matches one of the ETag values in the If-Match request header. If the conditional does not match, the 412 Precondition Failed response is returned instead.
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/If-Match
      * */
-    "If-Match": string;
+    "If-Match": `W/"${string}"` | `"${string}"` | "*";
     /**
    * The HTTP If-Modified-Since request header makes a request conditional. The server sends back the requested resource, with a 200 status, only if it has been modified after the date in the If-Modified-Since header. If the resource has not been modified since, the response is a 304 without any body, and the Last-Modified response header of the previous request contains the date of the last modification.
   
@@ -739,7 +752,7 @@ type simpleHeaders = {
   If the server sends back ranges, it uses the 206 Partial Content status code for the response. If the ranges are invalid, the server returns the 416 Range Not Satisfiable error.
    * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Range
   * */
-    Range: string;
+    Range: `bytes=${number}-${number}` | `bytes=${number}-` | `bytes=-${number}`;
     /**
      * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Referer
      * */
@@ -912,10 +925,33 @@ export type BaseHeaders = Partial<simpleHeaders & helmetHeadersT & experimentalH
     [key: string]: string;
 }>;
 /**
- * A map containing all headers as ArrayBuffers, so speed remains. There are several use cases of it:
- * 1) Don't define them in requests ( post(res){new HeadersMap({...headers}).prepare().toRes(res)} ). This is slow. Define maps BEFORE actual usage.
- * 2) You can pass them in LightMethod or HeavyMethod in shared property (but handle it manually)
- * 3) Don't define them before writing status on request. uWebSockets.js after first written header considers response as successful and puts "200" code automatically. Set headers AFTER validation in class controllers (handler function) and after writing status (or don't write it at all. It will be 200).
+* This function is created as a replacement for "HeadersMap" (which became deprecated in 1.1.0).
+* The most overhead when sending request doesn't come from utf16 -> utf8 conversion, but from many subsequent res.writeHeader, which is JS->C++ switch.
+* To reduce an amount of calling headers, you can use manual string concatenation and HTTP header separator - CRLF.
+* @notice this function doesn't create completely ready data to send. Look a the example below
+* @notice2 its return-type LIES. In fact it is just a concatenated string, but TS lies just for LSP help for the second param and, as a result, last header, value to which should be written in res.writeHeader
+* @example
+* //if all headers don't change
+* var headers = staticHeaders({
+*   "Content-Type": "text/plain"
+* }, "Etag") // However "Etag" doesn't have value yet
+* * var littleFasterHeaders = Buffer.from(headers)
+* server.get("/", (res)=>{
+*   // we put ETag's value to the right. This way we can combine static + dynamic headers in one single call
+*   res.writeHeader(littleFasterHeaders, 'W/"' + 123 + '"')
+*   res.end("ok")
+*
+*  // underneath this is the same (gain speed but lose TypeScript. Not bad if your head is a compiler)
+*  res.writeHeader("Content-Type: text/plain\r\nETag", 'W/"' + 123 + '"')
+*  // you can make right side look same as well
+*  res.writeHeader<string>("Content-Type", 'text/plain\r\nETag: W/"' + 123 + '"')
+* })
+*
+* */
+export declare function staticHeaders<T extends keyof RequiredBaseHeaders | (string & {})>(headers: BaseHeaders, likelyDynamicHeader: T): T;
+/**
+ * @deprecated because using ArrayBuffers vs strings in headers doesn't bring much benefit, as it turned out after some benchmarks (+ it uses Map class, so that's even slower). It is going to be removed in 2.0.0. When is it coming? Who knows.
+ * And YES, I removed description of it. Stick to "staticHeaders" or CRLF manipulations
  */
 export declare class HeadersMap<Opts extends BaseHeaders> extends Map {
     currentHeaders: undefined | Opts;
@@ -963,8 +999,6 @@ type CSP = Partial<typeof CSPDirs & {
  * Usual CSP directories. If you want more dirs:
  * 1) I will put more in soon
  * 2) use string concatenation (use BASE)
- * @example
- * new HeadersMap({...HeadersMap.baseObj, "Content-Security-Policy":setCSP({...CSPDirs}) + " your-dir: 'self';"})
  */
 export declare var CSPDirs: {
     /**
@@ -1036,5 +1070,31 @@ export declare var CSPDirs: {
      */
     "media-src": string[];
 };
-export type lowHeaders = Lowercase<keyof (simpleHeaders & helmetHeadersT & experimentalHeaders & CORSHeader)>;
+export type RequiredBaseHeaders = (simpleHeaders & helmetHeadersT & experimentalHeaders & CORSHeader);
+export type lowHeaders = Lowercase<keyof RequiredBaseHeaders>;
+/**
+* "Range" http header requires validation, so here you get it
+* @example
+* var data = Buffer.allocUnsafe(1024*1024)
+* server.get("/largeData", (res, req)=>{
+*   var range = req.getHeader("range")
+*   if(!range) return res.end(data)
+*   // so parseRange might modify "range" to suit requirements + check if header is right
+*   var parsedRange = parseRange(range, data.length - 1, 64*1024)
+*   // might be
+*   if(!parsedRange.ok) return res.writeStatus(parsedRange.code).end("bad")
+* })
+* */
+export declare function parseRange(range: string, maxEnd: number, maxChunk: number): {
+    ok: false;
+    code: "400" | "416";
+} | {
+    ok: true;
+    start: number;
+    end: number;
+};
+/**
+* This function takes methods that you registered on an endpoint and formats them to suit "Allow" header.
+* */
+export declare function typedAllowHeader(methodsArr: HttpMethods[]): string;
 export {};

package/dist/types/index.d.ts

@@ -1,10 +1,15 @@
-import type { BaseHeaders, lowHeaders } from "./http-headers.js";
+import type { BaseHeaders, lowHeaders, RequiredBaseHeaders } from "./http-headers.js";
 import { Buffer } from "node:buffer";
 import { EventEmitter } from "tseep";
 import type { CompressOptions, WebSocket, HttpRequest as uwsHttpRequest, TemplatedApp, HttpResponse as uwsHttpResponse, RecognizedString, us_socket_context_t } from "uWebSockets.js";
 /**
  * function to effortlessly mark response as aborted AND to attach an event emitter, so that you can easily scale the handler. If you don't need event emitter and only some res.aborted - set it by yourself (no overkill for the handler)
+ * If some utility expect import("@ublitzjs/core").HttpResponse, it means that they response to first go through this registerAbort
  * @param res
+ * @example
+ * console.log(Boolean(res.emitter)) // false
+ * registerAbort(res)
+ * console.log(Boolean(res.emitter)) // true
  */
 export declare function registerAbort(res: uwsHttpResponse): HttpResponse;
 /**
@@ -88,26 +93,47 @@ export interface HttpResponse<UserDataForWS = {}> extends uwsHttpResponse {
      */
     collect: (...any: any[]) => any;
     /**
-     * An event emitter, which lets you subscribe several listeners to "abort" event OR your own events, defined with Symbol().
+     * An event emitter, which lets you subscribe several listeners to "abort" event OR your own events, defined with Symbol() | other string
+     * @example
+     * res.emitter.once("abort", ()=>{
+     *   console.log("I have to clean up some random file descriptor")
+     *   // do cleanup
+     * })
      */
     emitter: EventEmitter<{
         abort: () => void;
         [k: symbol]: (...any: any[]) => void;
     }>;
     /**
-     * changes when res.onAborted fires.
+     * changes when res.onAborted fires (you have to use registerAbort for this)
      */
     aborted?: boolean;
     /**
      * You should set it manually when ending the response. Particularly useful if some error has fired and you are doubting whether res.aborted is a sufficient flag.
+     * @example
+     * function endResponse(res) {
+     *   if(res.aborted) return;
+     *   res.end("alright")
+     *   res.finished = true;
+     * }
      */
     finished?: boolean;
+    /**
+    * Writes key and value to HTTP response. See writeStatus and corking.
+    * It can actually write several values in a row, just be careful with string concatenation. If headers never change - use staticHeaders (and save typescript safety)
+    * @example
+    * res.writeHeader("Content-Type", "text/plain").writeHeader("Accept-Ranges", "bytes")
+    * // and a faster trick
+    * res.writeHeader("Content-Type: text/plain\r\nAccept-Ranges", "bytes")
+    * */
+    writeHeader<Key extends keyof RequiredBaseHeaders | Omit<RecognizedString, string> | (string & {})>(key: Key, val: Key extends keyof RequiredBaseHeaders ? RequiredBaseHeaders[Key] : RecognizedString): HttpResponse;
 }
 /**This HttpRequest is same as original uWS.HttpRequest, but getHeader method is typed for additional tips
  * @example
  * import {lowHeaders} from "@ublitzjs/core"
- * // some handler later
+ * // some handler later (not compulsory to specify lowHeaders. It is a default behaviour)
  * req.getHeader<lowHeaders>("content-type")
+ *
  */
 export interface HttpRequest extends uwsHttpRequest {
     getHeader<T extends RecognizedString = lowHeaders>(a: T): string;
@@ -128,7 +154,7 @@ type MergeObjects<T extends any[]> = T extends [infer First, ...infer Rest] ? Fi
  */
 export declare function extendApp<T extends object[]>(app: TemplatedApp, ...rest: T): Server & MergeObjects<T>;
 /**
- * conversion to ArrayBuffer ('cause transferring strings to uWS is really slow)
+ * @deprecated this conversion to arrayBuffer is not really necessary. You just have Buffer.from(""). Slicing that is rarely needed, and even if it is, that takes 4 lines of code
  */
 export declare function toAB(data: Buffer | string): ArrayBuffer;
 /**
@@ -220,6 +246,9 @@ export interface DocumentedWSBehavior<UserData> {
      */
     upgrade?: (res: HttpResponse<UserData>, req: HttpRequest, context: us_socket_context_t) => void | Promise<void>;
 }
+/**
+* let's believe, that in 20.61.0+ versions we get writeStatus.
+* */
 export type DeclarativeResType = {
     writeHeader(key: string, value: string): DeclarativeResType;
     writeQueryValue(key: string): DeclarativeResType;

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "@ublitzjs/core",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "types": "./dist/types/index.d.ts",
+  "files": ["dist", "LICENSE"],
+  "typesVersions": {
+    "*": {
+      ".": ["./dist/types/index.d.ts"]
+    }
+  },
+  "license": "MIT",
   "exports": {
     "types": "./dist/types/index.d.ts",
     "require": "./dist/cjs/index.js",
@@ -20,6 +27,7 @@
     "@babel/plugin-transform-modules-commonjs": "^7.28.6",
     "@types/node": "^25.2.1",
     "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "4.0.18",
     "esbuild": "^0.25.12",
     "tsd": "^0.33.0",
     "vitest": "^4.0.8",
@@ -31,7 +39,7 @@
     "build:cjs": "babel dist/esm --out-dir dist/cjs",
     "build:types": "tsc -p tsconfig.types.json",
     "build": "npm run build:types && npm run build:esm && npm run build:cjs",
-    "test": "tsd && vitest run"
+    "test": "tsd && vitest run tests/index.test.ts --coverage"
   },
   "tsd": {
     "directory": "tests"

package/USAGE.md

@@ -1,330 +0,0 @@
-> some examples will be shown using typescript, all examples are esm (but can also be cjs)
-
-# Setup main file
-
-In this section each code sample will show more features, so be ready to see them one by one.
-
-## no routers or other imports
-
-### without package
-
-```typescript
-import uWS from "uWebSockets.js";
-
-const server = uWS.App();
-
-server.any("/*", (res, req) => {
-  // manually handle this
-  res.writeStatus("404").end("Nothing to see here!");
-});
-
-// though I don't use "run", it is needed for example
-function run() {
-  server.listen(9001, (token) =>
-    token ? console.info("Start success") : console.error("Start failure")
-  );
-}
-
-run();
-```
-
-### with core package (low deps)
-
-```typescript
-import uWS from "uWebSockets.js";
-
-// c404 is an ArrayBuffer (not all codes are converted, don't worry), toAB - conversion helper
-import { c404, toAB } from "@ublitzjs/core";
-
-const server = uWS.App();
-
-var noFoundMessage = toAB("Nothing to see here!");
-server.any("/*", (res, req) => {
-  res.writeStatus(c404).end(notFoundMessage);
-});
-
-function run() {
-  server.listen(9001, (token) =>
-    token ? console.info("Start success") : console.error("Start failure")
-  );
-}
-
-run();
-```
-
-### with core package (better version)
-
-```typescript
-import uWS from "uWebSockets.js";
-
-// extendApp - lets you use or write extensions, notFoundConstructor - send 404 with a message
-import { extendApp, notFoundConstructor } from "@ublitzjs/core";
-
-// all extensions will be typed in typescript, so server.run call is also typed.
-const server = extendApp(
-  uWS.App(),
-  /* your extensions as a rest parameter. They will be bound to "server" */ {
-    run(/*for typescript*/ this: Server) {
-      this.listen(9001, (token) =>
-        token ? console.info("Start success") : console.error("Start failure")
-      );
-    },
-  } /*, you can put here as many as you want. */
-);
-
-server.any("/*", notFoundConstructor("Nothing to see here!"));
-
-// use your extension
-server.run();
-```
-
-And last example, just to show real-world use-case for extendApp
-
-```typescript
-import uWS from "uWebSockets.js";
-import { extendApp, notFoundConstructor } from "@ublitzjs/core";
-
-import { serverExtension as openapiExt } from "@ublitzjs/openapi";
-
-const server = extendApp(
-  uWS.App(),
-  // this is very basic, so for better examples - go find source repo
-  openapiExt({
-    openapi: "3.0.0",
-    info: {
-      title: "Some ublitzjs server",
-      version: "0.0.1",
-    },
-  }),
-  // your extension can also be here
-  {
-    run(this: Server) {
-      this.listen(9001, (token) =>
-        token ? console.info("Start success") : console.error("Start failure")
-      );
-    },
-  }
-);
-// this function is given by the extension
-await server.serveOpenApi("/docs", { build: false, path: "openapi.json" });
-
-server.any("/*", notFoundConstructor("Nothing to see here!"));
-
-server.run();
-```
-
-So in extendApp you put "extensions", as I call them.
-
-## With routers (mainly not @ublitzjs/router) and other imports
-
-### two modules with core package
-
-_main.js_
-
-```typescript
-import uWS from "uWebSockets.js";
-import { extendApp } from "@ublitzjs/core";
-import router from "./router.js";
-const server = extendApp(uWS.App());
-// register "plugins", not "extensions"
-server.register(router);
-server.listen(9001, () => {});
-```
-
-here you have imported your router and registered it as a plugin. So "extension" gives you NEW functionality, while "plugin" should use your current functionality
-
-_router.js_
-
-```typescript
-import type { Server } from "@ublitzjs/core";
-// for readability and
-export default (server: Server) => {
-  server.get("/simple", (res) => {
-    res.end("hello");
-  });
-};
-```
-
-### example with @ublitzjs/router
-
-_main.js_ - the same. Nothing changed at all <br>
-_router.js_
-
-```typescript
-import type { Server } from "@ublitzjs/core";
-import { Router } from "@ublitzjs/router";
-// again - better explanations in source repo.
-// Generally, router looks like OpenAPI
-const router = new Router({
-  // route
-  "/simple": {
-    // method
-    get(res) {
-      res.end("hello");
-    },
-  },
-});
-export default (server: Server) => {
-  router.bind(server).define("/simple", "get");
-};
-```
-
-So here I showed you how to setup a main file and split your code into modules
-
-# Headers
-
-## HeadersMap
-
-This class is used to convert all headers to ArrayBuffers and quickly set them on each request.
-
-```typescript
-import { HeadersMap, definePlugin, toAB, type Server } from "@ublitzjs/core";
-// init headers
-const htmlHeaders = new HeadersMap({
-  "Content-Type": "text/html",
-});
-// convert strings to ArrayBuffers -> it returns a function
-const setHeaders = htmlHeaders.prepare();
-
-export default (server: Server) => {
-  const html = toAB("<h1>Hello</h1>");
-  server.get("/", (res) => {
-    // and this function returns "res" object
-    setHeaders(res).end(html);
-  });
-};
-```
-
-Also there is HeadersMap.default (see in the code), HeadersMap.baseObj (also in the code), and HeadersMap.remove (you remove unwanted headers)
-
-## setCSP
-
-Creates a string of CSP, using array parameters.
-
-```typescript
-// in response (not recommended)
-res.writeHeader(
-  "Content-Security-Policy",
-  setCSP({ "default-src": ["'self'"] })
-);
-// in HeadersMap
-import { setCSP, HeadersMap, /*basic settings*/ CSPDirs } from "@ublitzjs";
-new HeadersMap({
-  "Content-Security-Policy": setCSP(
-    {
-      ...CSPDirs,
-      "connect-src": ["'self'", "https://example.com"],
-    },
-    /*remove directives in a rest param*/
-    "img-src",
-    "object-src"
-  ),
-}).prepare();
-```
-
-## lowHeaders
-
-Greatly fits when you need to use request.getHeader("sec-websocket-extensions"), but miss a letter or two. <br>
-See example below in "uWS types / DocumentedWS and DocumentedWSBehavior"
-
-# registerAbort
-
-this utility lets you extend your handlers in a very asynchronous manner and nothing will ever brake.<br>
-Emitter used here is "tseep", which is faster than node:events.
-
-```typescript
-import type { HttpResponse } from "@ublitzjs/core";
-function myOnAbort(res: HttpResponse) {
-  res.emitter.once("abort", () => {
-    /*do something*/
-  });
-}
-server.get("/", (res) => {
-  // use it
-  registerAbort(res);
-  console.log(/*added on the response*/ res.aborted, res.emitter);
-
-  res.emitter.once("abort", () => {
-    console.log("ABORTED");
-    // as an example
-    stopDatabaseTransaction();
-  });
-
-  myOnAbort();
-  /*here you something*/
-});
-```
-
-It is heavily used in @ublitzjs/req-body and @ublitzjs/static to stop file streams
-If you want a more interesting use-case, <a href="./examples/AsyncFunction.mts">Go here</a>
-
-# uWS types
-
-Another benefit of using this package are additional typescript docs for uWS, that they haven't added yet (I mean index.d.ts has no description yet).
-
-## DeclarativeResponse
-
-This class helps you define faster and more optimized controllers, because they are prebuilt before execution.<br>
-
-Instead of sending response dynamically each time with <code>res.end()</code> you generate the whole response with all headers and body right on the start of the application.<br>
-
-It is not something, that ublitzjs created (only <code>.writeHeaders</code> method), but rather just description it gives you with the class
-
-```typescript
-import { DeclarativeResponse } from "@ublitzjs";
-server.get(
-  "/fast-response",
-  new Declarative()
-    .writeHeader("Content-Type", "text/plain")
-    /*spec method*/ .writeHeaders({ Allow: "GET" })
-    .end("HI")
-);
-```
-
-## DocumentedWS and DocumentedWSBehavior
-
-These types add 3 methods to websocket object: sendFirstFragment, sendFragment, sendLastFragment.<br>
-More detailed description <a href="./types/uws-types.d.ts">here</a>
-
-```typescript
-import type { extendApp, DocumentedWSBehavior, lowHeaders } from "@ublitzjs/core";
-import uWS from "uWebSockets.js";
-const server = extendApp(uWS.App()) // better for ts
-server.ws("/*", {
-  upgrade(res, req, context) {
-    res.upgrade(
-      { url: req.getUrl() },
-      req.getHeader</*adds typescript support*/ lowHeaders>(
-        "sec-websocket-key"
-      ),
-      req.getHeader<lowHeaders>("sec-websocket-protocol"),
-      req.getHeader<lowHeaders>("sec-websocket-extensions"),
-      context
-    );
-  },
-  async open(ws) {
-    ws.sendFirstFragment("hello1\n");
-    ws.sendFragment("hello2\n");
-    ws.sendLastFragment("end hello");
-  },
-  close(ws){
-    //typed safety flag
-    ws.closed = true;
-  }
-  message(ws){
-    setTimeout(()=>{
-      //acts like res.aborted
-      if(ws.closed) return;
-      ws.send("hello")
-    }, 100);
-  },
-});
-```
-
-# Bundling
-
-Best efficiency and start time can be achieved if the code is bundled and minified.<br>
-For this purpose you can use "esbuild" (at least it was tested and worked for both cjs and esm formats).<br>
-The only thing to remember: when you use it for bundling, don't forget to put "uWebSockets.js" to "external" array.<br>
-<a href="./examples/esbuild.mjs">Example 1</a><br>
-<a href="./tests/esbuild.test.ts">Dynamic example 2</a>

package/babel.config.json

@@ -1,8 +0,0 @@
-{
-  "plugins": [
-    [
-      "@babel/plugin-transform-modules-commonjs", 
-      { "importInterop": "node" }
-    ]
-  ]
-}