@eslym/sveltekit-adapter-bun 1.0.7 → 1.0.9

package/dist/index.js

@@ -20,6 +20,277 @@ import commonjs from "@rollup/plugin-commonjs";
 import json from "@rollup/plugin-json";
 import {join as join2} from "path/posix";
 
+// node_modules/devalue/src/utils.js
+function is_primitive(thing) {
+  return Object(thing) !== thing;
+}
+function is_plain_object(thing) {
+  const proto = Object.getPrototypeOf(thing);
+  return proto === Object.prototype || proto === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+function get_type(thing) {
+  return Object.prototype.toString.call(thing).slice(8, -1);
+}
+var get_escaped_char = function(char) {
+  switch (char) {
+    case '"':
+      return '\\"';
+    case "<":
+      return "\\u003C";
+    case "\\":
+      return "\\\\";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\t":
+      return "\\t";
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+  }
+};
+function stringify_string(str) {
+  let result = "";
+  let last_pos = 0;
+  const len = str.length;
+  for (let i = 0;i < len; i += 1) {
+    const char = str[i];
+    const replacement = get_escaped_char(char);
+    if (replacement) {
+      result += str.slice(last_pos, i) + replacement;
+      last_pos = i + 1;
+    }
+  }
+  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+function enumerable_symbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable);
+}
+var escaped = {
+  "<": "\\u003C",
+  "\\": "\\\\",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "\t": "\\t",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+
+class DevalueError extends Error {
+  constructor(message, keys) {
+    super(message);
+    this.name = "DevalueError";
+    this.path = keys.join("");
+  }
+}
+var object_proto_names = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+
+// node_modules/devalue/src/uneval.js
+function uneval(value, replacer) {
+  const counts = new Map;
+  const keys = [];
+  const custom = new Map;
+  function walk(thing) {
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys);
+    }
+    if (!is_primitive(thing)) {
+      if (counts.has(thing)) {
+        counts.set(thing, counts.get(thing) + 1);
+        return;
+      }
+      counts.set(thing, 1);
+      if (replacer) {
+        const str2 = replacer(thing);
+        if (typeof str2 === "string") {
+          custom.set(thing, str2);
+          return;
+        }
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "BigInt":
+        case "String":
+        case "Boolean":
+        case "Date":
+        case "RegExp":
+          return;
+        case "Array":
+          thing.forEach((value2, i) => {
+            keys.push(`[${i}]`);
+            walk(value2);
+            keys.pop();
+          });
+          break;
+        case "Set":
+          Array.from(thing).forEach(walk);
+          break;
+        case "Map":
+          for (const [key, value2] of thing) {
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+            walk(value2);
+            keys.pop();
+          }
+          break;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys);
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys);
+          }
+          for (const key in thing) {
+            keys.push(`.${key}`);
+            walk(thing[key]);
+            keys.pop();
+          }
+      }
+    }
+  }
+  walk(value);
+  const names = new Map;
+  Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
+    names.set(entry[0], get_name(i));
+  });
+  function stringify(thing) {
+    if (names.has(thing)) {
+      return names.get(thing);
+    }
+    if (is_primitive(thing)) {
+      return stringify_primitive(thing);
+    }
+    if (custom.has(thing)) {
+      return custom.get(thing);
+    }
+    const type = get_type(thing);
+    switch (type) {
+      case "Number":
+      case "String":
+      case "Boolean":
+        return `Object(${stringify(thing.valueOf())})`;
+      case "RegExp":
+        return `new RegExp(${stringify_string(thing.source)}, "${thing.flags}")`;
+      case "Date":
+        return `new Date(${thing.getTime()})`;
+      case "Array":
+        const members = thing.map((v, i) => (i in thing) ? stringify(v) : "");
+        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
+        return `[${members.join(",")}${tail}]`;
+      case "Set":
+      case "Map":
+        return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
+      default:
+        const obj = `{${Object.keys(thing).map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(",")}}`;
+        const proto = Object.getPrototypeOf(thing);
+        if (proto === null) {
+          return Object.keys(thing).length > 0 ? `Object.assign(Object.create(null),${obj})` : `Object.create(null)`;
+        }
+        return obj;
+    }
+  }
+  const str = stringify(value);
+  if (names.size) {
+    const params = [];
+    const statements = [];
+    const values = [];
+    names.forEach((name2, thing) => {
+      params.push(name2);
+      if (custom.has(thing)) {
+        values.push(custom.get(thing));
+        return;
+      }
+      if (is_primitive(thing)) {
+        values.push(stringify_primitive(thing));
+        return;
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+          values.push(`Object(${stringify(thing.valueOf())})`);
+          break;
+        case "RegExp":
+          values.push(thing.toString());
+          break;
+        case "Date":
+          values.push(`new Date(${thing.getTime()})`);
+          break;
+        case "Array":
+          values.push(`Array(${thing.length})`);
+          thing.forEach((v, i) => {
+            statements.push(`${name2}[${i}]=${stringify(v)}`);
+          });
+          break;
+        case "Set":
+          values.push(`new Set`);
+          statements.push(`${name2}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`);
+          break;
+        case "Map":
+          values.push(`new Map`);
+          statements.push(`${name2}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`);
+          break;
+        default:
+          values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
+          Object.keys(thing).forEach((key) => {
+            statements.push(`${name2}${safe_prop(key)}=${stringify(thing[key])}`);
+          });
+      }
+    });
+    statements.push(`return ${str}`);
+    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
+  } else {
+    return str;
+  }
+}
+var get_name = function(num) {
+  let name2 = "";
+  do {
+    name2 = chars[num % chars.length] + name2;
+    num = ~~(num / chars.length) - 1;
+  } while (num >= 0);
+  return reserved.test(name2) ? `${name2}0` : name2;
+};
+var escape_unsafe_char = function(c) {
+  return escaped[c] || c;
+};
+var escape_unsafe_chars = function(str) {
+  return str.replace(unsafe_chars, escape_unsafe_char);
+};
+var safe_key = function(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
+};
+var safe_prop = function(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
+};
+var stringify_primitive = function(thing) {
+  if (typeof thing === "string")
+    return stringify_string(thing);
+  if (thing === undefined)
+    return "void 0";
+  if (thing === 0 && 1 / thing < 0)
+    return "-0";
+  const str = String(thing);
+  if (typeof thing === "number")
+    return str.replace(/^(-)?0\./, "$1.");
+  if (typeof thing === "bigint")
+    return thing + "n";
+  return str;
+};
+var chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+var unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
+var reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
 // src/symbols.ts
 var symServer = Symbol.for(`${name}/server`);
 var symUpgrades = Symbol.for(`${name}/upgrades`);
@@ -376,7 +647,7 @@ function adapter(userOpts = {}) {
       delete pkg.devDependencies;
       writeFileSync(`${out}/package.json`, JSON.stringify(pkg, null, 2) + "\n");
       if (opts.exportPrerender) {
-        const js = `export const paths = ${JSON.stringify(builder.prerendered.paths)};\n` + `export const prerendered = ${JSON.stringify(builder.prerendered.pages)};\n` + `export const assets = ${JSON.stringify(builder.prerendered.assets)};\n` + `export const redirects = ${JSON.stringify(builder.prerendered.redirects)};\n` + `export default { paths, prerendered, assets, redirects };\n`;
+        const js = `export const paths = ${uneval(builder.prerendered.paths)};\n` + `export const prerendered = ${uneval(builder.prerendered.pages)};\n` + `export const assets = ${uneval(builder.prerendered.assets)};\n` + `export const redirects = ${uneval(builder.prerendered.redirects)};\n` + `export default { paths, prerendered, assets, redirects };\n`;
         writeFileSync(`${out}/prerendered.js`, "//@bun\n" + transpiler.transformSync(js));
       }
       builder.log.success(`Build done.`);

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="bun-types" />
+/// <reference types="node" />
 /// <reference types="bun-types" />
-import type { WebSocketHandler as BunWSHandler } from 'bun';
+import type { WebSocketHandler as BunWSHandler, ServerWebSocket } from 'bun';
 import type { Server } from 'bun';
 export type ServeOptions = {
     port: number;
@@ -13,7 +14,55 @@ export type ServeOptions = {
     xffDepth?: number;
 };
 export type WebSocketOptions = Omit<BunWSHandler, 'message' | 'open' | 'close' | 'ping' | 'pong' | 'drain'>;
-export type WebSocketHandler<T extends WebSocketHandler<any>> = Pick<BunWSHandler<T>, 'message' | 'open' | 'drain' | 'ping' | 'pong' | 'close'>;
+export interface WebSocketHandler {
+    /**
+     * Called when the server receives an incoming message.
+     *
+     * If the message is not a `string`, its type is based on the value of `binaryType`.
+     * - if `nodebuffer`, then the message is a `Buffer`.
+     * - if `arraybuffer`, then the message is an `ArrayBuffer`.
+     * - if `uint8array`, then the message is a `Uint8Array`.
+     *
+     * @param ws The websocket that sent the message
+     * @param message The message received
+     */
+    message(ws: ServerWebSocket<this>, message: string | Buffer): void | Promise<void>;
+    /**
+     * Called when a connection is opened.
+     *
+     * @param ws The websocket that was opened
+     */
+    open?(ws: ServerWebSocket<this>): void | Promise<void>;
+    /**
+     * Called when a connection was previously under backpressure,
+     * meaning it had too many queued messages, but is now ready to receive more data.
+     *
+     * @param ws The websocket that is ready for more data
+     */
+    drain?(ws: ServerWebSocket<this>): void | Promise<void>;
+    /**
+     * Called when a connection is closed.
+     *
+     * @param ws The websocket that was closed
+     * @param code The close code
+     * @param message The close message
+     */
+    close?(ws: ServerWebSocket<this>, code: number, reason: string): void | Promise<void>;
+    /**
+     * Called when a ping is sent.
+     *
+     * @param ws The websocket that received the ping
+     * @param data The data sent with the ping
+     */
+    ping?(ws: ServerWebSocket<this>, data: Buffer): void | Promise<void>;
+    /**
+     * Called when a pong is received.
+     *
+     * @param ws The websocket that received the ping
+     * @param data The data sent with the ping
+     */
+    pong?(ws: ServerWebSocket<this>, data: Buffer): void | Promise<void>;
+}
 export interface AdapterPlatform {
     /**
      * The original request received from Bun.serve
@@ -32,7 +81,7 @@ export interface AdapterPlatform {
      * @param response The response to mark
      * @param ws The websocket handler
      */
-    markForUpgrade(response: Response, ws: WebSocketHandler<any>): Response;
+    markForUpgrade(response: Response, ws: WebSocketHandler): Response;
 }
 export type PreCompressOptions = {
     [k in 'gzip' | 'brotli']?: boolean;

package/package.json

@@ -34,5 +34,5 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "rollup": "^4.18.0"
   },
-  "version": "1.0.7"
+  "version": "1.0.9"
 }