@siddharatha/adapter-node-rolldown 1.0.9 → 1.1.4

package/files/index.js

@@ -1,40 +1,488 @@
-import polka from 'polka';
+import http from 'node:http';
+import process from 'node:process';
 import { handler } from 'HANDLER';
-import { createCompressionMiddleware, createStaticMiddleware } from 'MIDDLEWARES';
+import { env, timeout_env } from 'ENV';
+import { createRequire } from 'node:module';
 
-const app = polka();
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
 
-// Serve static assets (use optimized static middleware)
-app.use(createStaticMiddleware('client'));
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch {}
+			if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
 
-// Serve prerendered pages if they exist
-try {
-    const { existsSync } = await import('node:fs');
-    if (existsSync('prerendered')) {
-        app.use(createStaticMiddleware('prerendered', false));
-    }
-} catch (e) {
-    // Skip if prerendered doesn't exist
+const require$2 = createRequire(import.meta.url);
+function __require$1() { return require$2("node:http"); }
+
+function every (arr, cb) {
+	var i=0, len=arr.length;
+
+	for (; i < len; i++) {
+		if (!cb(arr[i], i, arr)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+const SEP = '/';
+// Types ~> static, param, any, optional
+const STYPE=0, PTYPE=1, ATYPE=2, OTYPE=3;
+// Char Codes ~> / : *
+const SLASH=47, COLON=58, ASTER=42, QMARK=63;
+
+function strip(str) {
+	if (str === SEP) return str;
+	(str.charCodeAt(0) === SLASH) && (str=str.substring(1));
+	var len = str.length - 1;
+	return str.charCodeAt(len) === SLASH ? str.substring(0, len) : str;
+}
+
+function split(str) {
+	return (str=strip(str)) === SEP ? [SEP] : str.split(SEP);
 }
 
-// Register compression for dynamic responses
-app.use(createCompressionMiddleware());
+function isMatch(arr, obj, idx) {
+	idx = arr[idx];
+	return (obj.val === idx && obj.type === STYPE) || (idx === SEP ? obj.type > PTYPE : obj.type !== STYPE && (idx || '').endsWith(obj.end));
+}
+
+function match(str, all) {
+	var i=0, tmp, segs=split(str), len=segs.length, l;
+	var fn = isMatch.bind(isMatch, segs);
+
+	for (; i < all.length; i++) {
+		tmp = all[i];
+		if ((l=tmp.length) === len || (l < len && tmp[l-1].type === ATYPE) || (l > len && tmp[l-1].type === OTYPE)) {
+			if (every(tmp, fn)) return tmp;
+		}
+	}
+
+	return [];
+}
+
+function parse(str) {
+	if (str === SEP) {
+		return [{ old:str, type:STYPE, val:str, end:'' }];
+	}
+
+	var c, x, t, sfx, nxt=strip(str), i=-1, j=0, len=nxt.length, out=[];
+
+	while (++i < len) {
+		c = nxt.charCodeAt(i);
+
+		if (c === COLON) {
+			j = i + 1; // begining of param
+			t = PTYPE; // set type
+			x = 0; // reset mark
+			sfx = '';
+
+			while (i < len && nxt.charCodeAt(i) !== SLASH) {
+				c = nxt.charCodeAt(i);
+				if (c === QMARK) {
+					x=i; t=OTYPE;
+				} else if (c === 46 && sfx.length === 0) {
+					sfx = nxt.substring(x=i);
+				}
+				i++; // move on
+			}
+
+			out.push({
+				old: str,
+				type: t,
+				val: nxt.substring(j, x||i),
+				end: sfx
+			});
 
-// Handle all SvelteKit requests
-app.use(handler);
+			// shorten string & update pointers
+			nxt=nxt.substring(i); len-=i; i=0;
 
-// Get port and host from environment
-const PORT = parseInt(process.env.PORT || '3000', 10);
-const HOST = process.env.HOST || '0.0.0.0';
+			continue; // loop
+		} else if (c === ASTER) {
+			out.push({
+				old: str,
+				type: ATYPE,
+				val: nxt.substring(i),
+				end: ''
+			});
+			continue; // loop
+		} else {
+			j = i;
+			while (i < len && nxt.charCodeAt(i) !== SLASH) {
+				++i; // skip to next slash
+			}
+			out.push({
+				old: str,
+				type: STYPE,
+				val: nxt.substring(j, i),
+				end: ''
+			});
+			// shorten string & update pointers
+			nxt=nxt.substring(i); len-=i; i=j=0;
+		}
+	}
 
-// Start server
-app.listen(PORT, HOST, () => {
-    const displayHost = HOST === '0.0.0.0' ? 'localhost' : HOST;
-    console.log(`\n✓ Server running on http://${displayHost}:${PORT}\n`);
+	return out;
+}
+
+function exec(str, arr) {
+	var i=0, x, y, segs=split(str), out={};
+	for (; i < arr.length; i++) {
+		x=segs[i]; y=arr[i];
+		if (x === SEP) continue;
+		if (x !== void 0 && y.type | 2 === OTYPE) {
+			out[ y.val ] = x.replace(y.end, '');
+		}
+	}
+	return out;
+}
+
+var matchit = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	exec: exec,
+	match: match,
+	parse: parse
 });
 
-// Export for instrumentation
-export const path = '/';
-export const host = HOST;
-export const port = PORT;
-export const server = app.server;
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(matchit);
+
+var trouter;
+var hasRequiredTrouter;
+
+function requireTrouter () {
+	if (hasRequiredTrouter) return trouter;
+	hasRequiredTrouter = 1;
+	const { exec, match, parse } = require$$0;
+
+	class Trouter {
+		constructor(opts) {
+			this.opts = opts || {};
+			this.routes = {};
+			this.handlers = {};
+
+			this.all = this.add.bind(this, '*');
+			this.get = this.add.bind(this, 'GET');
+			this.head = this.add.bind(this, 'HEAD');
+			this.patch = this.add.bind(this, 'PATCH');
+			this.options = this.add.bind(this, 'OPTIONS');
+	    this.connect = this.add.bind(this, 'CONNECT');
+			this.delete = this.add.bind(this, 'DELETE');
+	    this.trace = this.add.bind(this, 'TRACE');
+			this.post = this.add.bind(this, 'POST');
+			this.put = this.add.bind(this, 'PUT');
+		}
+
+		add(method, pattern, ...fns) {
+			// Save decoded pattern info
+			if (this.routes[method] === void 0) this.routes[method]=[];
+			this.routes[method].push(parse(pattern));
+			// Save route handler(s)
+			if (this.handlers[method] === void 0) this.handlers[method]={};
+			this.handlers[method][pattern] = fns;
+			// Allow chainable
+			return this;
+		}
+
+		find(method, url) {
+			let arr = match(url, this.routes[method] || []);
+			if (arr.length === 0) {
+				arr = match(url, this.routes[method='*'] || []);
+				if (!arr.length) return false;
+			}
+			return {
+				params: exec(url, arr),
+				handlers: this.handlers[method][arr[0].old]
+			};
+		}
+	}
+
+	trouter = Trouter;
+	return trouter;
+}
+
+const require$1 = createRequire(import.meta.url);
+function __require() { return require$1("node:querystring"); }
+
+var url;
+var hasRequiredUrl;
+
+function requireUrl () {
+	if (hasRequiredUrl) return url;
+	hasRequiredUrl = 1;
+	url = function (req) {
+		let url = req.url;
+		if (url === void 0) return url;
+
+		let obj = req._parsedUrl;
+		if (obj && obj._raw === url) return obj;
+
+		obj = {};
+		obj.query = obj.search = null;
+		obj.href = obj.path = obj.pathname = url;
+
+		let idx = url.indexOf('?', 1);
+		if (idx !== -1) {
+			obj.search = url.substring(idx);
+			obj.query = obj.search.substring(1);
+			obj.pathname = url.substring(0, idx);
+		}
+
+		obj._raw = url;
+
+		return (req._parsedUrl = obj);
+	};
+	return url;
+}
+
+var polka$1;
+var hasRequiredPolka;
+
+function requirePolka () {
+	if (hasRequiredPolka) return polka$1;
+	hasRequiredPolka = 1;
+	const http = __require$1();
+	const Router = requireTrouter();
+	const { parse } = __require();
+	const parser = requireUrl();
+
+	function lead(x) {
+		return x.charCodeAt(0) === 47 ? x : ('/' + x);
+	}
+
+	function value(x) {
+	  let y = x.indexOf('/', 1);
+	  return y > 1 ? x.substring(0, y) : x;
+	}
+
+	function mutate(str, req) {
+		req.url = req.url.substring(str.length) || '/';
+		req.path = req.path.substring(str.length) || '/';
+	}
+
+	function onError(err, req, res, next) {
+		let code = (res.statusCode = err.code || err.status || 500);
+		res.end(err.length && err || err.message || http.STATUS_CODES[code]);
+	}
+
+	class Polka extends Router {
+		constructor(opts={}) {
+			super(opts);
+			this.apps = {};
+			this.wares = [];
+			this.bwares = {};
+			this.parse = parser;
+			this.server = opts.server;
+			this.handler = this.handler.bind(this);
+			this.onError = opts.onError || onError; // catch-all handler
+			this.onNoMatch = opts.onNoMatch || this.onError.bind(null, { code:404 });
+		}
+
+		add(method, pattern, ...fns) {
+			let base = lead(value(pattern));
+			if (this.apps[base] !== void 0) throw new Error(`Cannot mount ".${method.toLowerCase()}('${lead(pattern)}')" because a Polka application at ".use('${base}')" already exists! You should move this handler into your Polka application instead.`);
+			return super.add(method, pattern, ...fns);
+		}
+
+		use(base, ...fns) {
+			if (typeof base === 'function') {
+				this.wares = this.wares.concat(base, fns);
+			} else if (base === '/') {
+				this.wares = this.wares.concat(fns);
+			} else {
+				base = lead(base);
+				fns.forEach(fn => {
+					if (fn instanceof Polka) {
+						this.apps[base] = fn;
+					} else {
+						let arr = this.bwares[base] || [];
+						arr.length > 0 || arr.push((r, _, nxt) => (mutate(base, r),nxt()));
+						this.bwares[base] = arr.concat(fn);
+					}
+				});
+			}
+			return this; // chainable
+		}
+
+		listen() {
+			(this.server = this.server || http.createServer()).on('request', this.handler);
+			this.server.listen.apply(this.server, arguments);
+			return this;
+		}
+
+		handler(req, res, info) {
+			info = info || this.parse(req);
+			let fns=[], arr=this.wares, obj=this.find(req.method, info.pathname);
+			req.originalUrl = req.originalUrl || req.url;
+			let base = value(req.path = info.pathname);
+			if (this.bwares[base] !== void 0) {
+				arr = arr.concat(this.bwares[base]);
+			}
+			if (obj) {
+				fns = obj.handlers;
+				req.params = obj.params;
+			} else if (this.apps[base] !== void 0) {
+				mutate(base, req); info.pathname=req.path; //=> updates
+				fns.push(this.apps[base].handler.bind(null, req, res, info));
+			} else if (fns.length === 0) {
+				fns.push(this.onNoMatch);
+			}
+			// Grab addl values from `info`
+			req.search = info.search;
+			req.query = parse(info.query);
+			// Exit if only a single function
+			let i=0, len=arr.length, num=fns.length;
+			if (len === i && num === 1) return fns[0](req, res);
+			// Otherwise loop thru all middlware
+			let next = err => err ? this.onError(err, req, res, next) : loop();
+			let loop = _ => res.finished || (i < len) && arr[i++](req, res, next);
+			arr = arr.concat(fns);
+			len += num;
+			loop(); // init
+		}
+	}
+
+	polka$1 = opts => new Polka(opts);
+	return polka$1;
+}
+
+var polkaExports = requirePolka();
+var polka = /*@__PURE__*/getDefaultExportFromCjs(polkaExports);
+
+const path = env('SOCKET_PATH', false);
+const host = env('HOST', '0.0.0.0');
+const port = env('PORT', !path && '3000');
+
+const shutdown_timeout = parseInt(env('SHUTDOWN_TIMEOUT', '30'));
+const idle_timeout = parseInt(env('IDLE_TIMEOUT', '0'));
+const listen_pid = parseInt(env('LISTEN_PID', '0'));
+const listen_fds = parseInt(env('LISTEN_FDS', '0'));
+// https://www.freedesktop.org/software/systemd/man/latest/sd_listen_fds.html
+const SD_LISTEN_FDS_START = 3;
+
+if (listen_pid !== 0 && listen_pid !== process.pid) {
+    throw new Error(`received LISTEN_PID ${listen_pid} but current process id is ${process.pid}`);
+}
+if (listen_fds > 1) {
+    throw new Error(
+        `only one socket is allowed for socket activation, but LISTEN_FDS was set to ${listen_fds}`
+    );
+}
+
+const socket_activation = listen_pid === process.pid && listen_fds === 1;
+
+let requests = 0;
+/** @type {NodeJS.Timeout | void} */
+let shutdown_timeout_id;
+/** @type {NodeJS.Timeout | void} */
+let idle_timeout_id;
+
+// Initialize the HTTP server here so that we can set properties before starting to listen.
+// Otherwise, polka delays creating the server until listen() is called. Settings these
+// properties after the server has started listening could lead to race conditions.
+const httpServer = http.createServer();
+
+const keep_alive_timeout = timeout_env('KEEP_ALIVE_TIMEOUT');
+if (keep_alive_timeout !== undefined) {
+    // Convert the keep-alive timeout from seconds to milliseconds (the unit Node.js expects).
+    httpServer.keepAliveTimeout = keep_alive_timeout * 1000;
+}
+
+const headers_timeout = timeout_env('HEADERS_TIMEOUT');
+if (headers_timeout !== undefined) {
+    // Convert the headers timeout from seconds to milliseconds (the unit Node.js expects).
+    httpServer.headersTimeout = headers_timeout * 1000;
+}
+
+const server = polka({ server: httpServer }).use(handler);
+
+if (socket_activation) {
+    server.listen({ fd: SD_LISTEN_FDS_START }, () => {
+        console.log(`Listening on file descriptor ${SD_LISTEN_FDS_START}`);
+    });
+} else {
+    server.listen({ path, host, port }, () => {
+        console.log(`Listening on ${path || `http://${host}:${port}`}`);
+    });
+}
+
+/** @param {'SIGINT' | 'SIGTERM' | 'IDLE'} reason */
+function graceful_shutdown(reason) {
+    if (shutdown_timeout_id) return;
+
+    // If a connection was opened with a keep-alive header close() will wait for the connection to
+    // time out rather than close it even if it is not handling any requests, so call this first
+    httpServer.closeIdleConnections();
+
+    httpServer.close((error) => {
+        // occurs if the server is already closed
+        if (error) return;
+
+        if (shutdown_timeout_id) {
+            clearTimeout(shutdown_timeout_id);
+        }
+        if (idle_timeout_id) {
+            clearTimeout(idle_timeout_id);
+        }
+
+        // @ts-expect-error custom events cannot be typed
+        process.emit('sveltekit:shutdown', reason);
+    });
+
+    shutdown_timeout_id = setTimeout(() => httpServer.closeAllConnections(), shutdown_timeout * 1000);
+}
+
+httpServer.on(
+    'request',
+    /** @param {import('node:http').IncomingMessage} req */
+    (req) => {
+        requests++;
+
+        if (socket_activation && idle_timeout_id) {
+            idle_timeout_id = clearTimeout(idle_timeout_id);
+        }
+
+        req.on('close', () => {
+            requests--;
+
+            if (shutdown_timeout_id) {
+                // close connections as soon as they become idle, so they don't accept new requests
+                httpServer.closeIdleConnections();
+            }
+            if (requests === 0 && socket_activation && idle_timeout) {
+                idle_timeout_id = setTimeout(() => graceful_shutdown('IDLE'), idle_timeout * 1000);
+            }
+        });
+    }
+);
+
+process.on('SIGTERM', graceful_shutdown);
+process.on('SIGINT', graceful_shutdown);
+
+export { host, path, port, server };

package/files/shims.js

@@ -1,6 +1,32 @@
-// Polyfills for Node.js environment
-import { installPolyfills } from '@sveltejs/kit/node/polyfills';
+import buffer from 'node:buffer';
+import { webcrypto } from 'node:crypto';
 
-if (JSON.parse('POLYFILL')) {
-    installPolyfills();
+// `buffer.File` was added in Node 18.13.0 while the `File` global was added in Node 20.0.0
+const File = /** @type {import('node:buffer') & { File?: File}} */ (buffer).File;
+
+/** @type {Record<string, any>} */
+const globals = {
+	crypto: webcrypto,
+	File
+};
+
+// exported for dev/preview and node environments
+/**
+ * Make various web APIs available as globals:
+ * - `crypto`
+ * - `File`
+ */
+function installPolyfills() {
+	for (const name in globals) {
+		if (name in globalThis) continue;
+
+		Object.defineProperty(globalThis, name, {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: globals[name]
+		});
+	}
 }
+
+installPolyfills();