@johntalton/http-util 1.0.0

package/src/content-disposition.js

@@ -0,0 +1,52 @@
+/**
+ * @typedef {Object} Disposition
+ * @property {string} disposition
+ * @property {Map<string, string>} parameters
+ * @property {string} [name]
+ * @property {string} [filename]
+ */
+
+export const DISPOSITION_SEPARATOR = {
+	PARAMETER: ';',
+	KVP: '='
+}
+
+export const DISPOSITION_PARAM_NAME = 'name'
+export const DISPOSITION_PARAM_FILENAME = 'filename'
+
+/**
+ * @param {string} contentDispositionHeader
+ * @returns {Disposition|undefined}
+ */
+export function parseContentDisposition(contentDispositionHeader) {
+	if(contentDispositionHeader === undefined) { return undefined }
+
+	const [ disposition, ...parameterSet ] = contentDispositionHeader.trim().split(DISPOSITION_SEPARATOR.PARAMETER).map(entry => entry.trim())
+	const parameters = new Map(parameterSet.map(parameter => {
+		const [ key, value ] = parameter.split(DISPOSITION_SEPARATOR.KVP).map(p => p.trim())
+		return [ key, value ]
+	}))
+
+	const name = parameters.get(DISPOSITION_PARAM_NAME)
+	const filename = parameters.get(DISPOSITION_PARAM_FILENAME)
+
+	return {
+		disposition,
+		parameters,
+		name, filename
+	}
+}
+
+// console.log(parseContentDisposition())
+// // console.log(parseContentDisposition(null))
+// console.log(parseContentDisposition(''))
+// console.log(parseContentDisposition('form-data'))
+// console.log(parseContentDisposition('    form-data ; name'))
+// console.log(parseContentDisposition('form-data; name="key"'))
+
+// console.log(parseContentDisposition('inline'))
+// console.log(parseContentDisposition('attachment'))
+// console.log(parseContentDisposition('attachment; filename="file name.jpg"'))
+// console.log(parseContentDisposition('attachment; filename*=UTF-8\'\'file%20name.jpg'))
+// console.log(parseContentDisposition('attachment; filename*=UTF-8\'\'file%20name.jpg'))
+// console.log(parseContentDisposition('form-data;title*=us-ascii\'en-us\'This%20is%20%2A%2A%2Afun%2A%2A%2A'))

package/src/content-type.js

@@ -0,0 +1,140 @@
+
+export const MIME_TYPE_JSON = 'application/json'
+export const MIME_TYPE_TEXT = 'text/plain'
+export const MIME_TYPE_EVENT_STREAM = 'text/event-stream'
+export const MIME_TYPE_XML = 'application/xml'
+export const MIME_TYPE_URL_FORM_DATA = 'application/x-www-form-urlencoded'
+export const MIME_TYPE_MULTIPART_FORM_DATA = 'multipart/form-data'
+export const MIME_TYPE_OCTET_STREAM = 'application/octet-stream'
+
+export const KNOWN_CONTENT_TYPES = [
+	'application', 'audio', 'image', 'message',
+	'multipart','text', 'video'
+]
+
+export const TYPE_X_TOKEN_PREFIX = 'X-'
+
+export const SPECIAL_CHARS = [
+	// special
+	'(', ')', '<', '>',
+	'@', ',', ';', ':',
+	'\\', '"', '/', '[',
+	']', '?', '.', '=',
+	// space
+	' ', '\u000B', '\u000C',
+	// control
+	'\n', '\r', '\t'
+]
+
+/**
+ * @param {string} c
+ */
+export function isWhitespace(c){ return /\s/.test(c) }
+
+/**
+ * @param {string|undefined} value
+ */
+export function hasSpecialChar(value) {
+  if(value === undefined) { return false }
+  for(const special of SPECIAL_CHARS) {
+    if(value.includes(special)) { return true}
+  }
+
+  return false
+}
+
+/**
+ * @typedef {Object} ContentType
+ * @property {string} mimetype
+ * @property {string} mimetypeRaw
+ * @property {string} type
+ * @property {string} subtype
+ * @property {string} [charset]
+ * @property {Map<string, string>} parameters
+ */
+
+export const CONTENT_TYPE_SEPARATOR = {
+	SUBTYPE: '/',
+	PARAMETER: ';',
+	KVP: '='
+}
+
+export const CHARSET_UTF8 = 'utf8'
+export const CHARSET = 'charset'
+export const PARAMETER_CHARSET_UTF8 = `${CHARSET}${CONTENT_TYPE_SEPARATOR.KVP}${CHARSET_UTF8}`
+export const CONTENT_TYPE_JSON = `${MIME_TYPE_JSON}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+export const CONTENT_TYPE_TEXT = `${MIME_TYPE_TEXT}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+
+/** @type {ContentType} */
+export const WELL_KNOWN_JSON = {
+	mimetype: 'application/json',
+	mimetypeRaw: 'application/json',
+	type: 'application',
+	subtype: 'json',
+	charset: 'utf8',
+	parameters: new Map()
+}
+
+export const WELL_KNOWN_CONTENT_TYPES = new Map([
+	[ 'application/json', WELL_KNOWN_JSON ],
+	[ 'application/json;charset=utf8', WELL_KNOWN_JSON ]
+])
+
+
+/**
+ * @param {string|undefined} contentTypeHeader
+ * @returns {ContentType|undefined}
+ */
+export function parseContentType(contentTypeHeader) {
+	if(contentTypeHeader === undefined) { return undefined }
+	if(contentTypeHeader === null) { return undefined }
+
+	const wellKnown = WELL_KNOWN_CONTENT_TYPES.get(contentTypeHeader)
+	if(wellKnown !== undefined) { return wellKnown }
+
+	const [ mimetypeRaw, ...parameterSet ] = contentTypeHeader.split(CONTENT_TYPE_SEPARATOR.PARAMETER)
+	if(mimetypeRaw === undefined) { return undefined }
+	if(mimetypeRaw === '') { return undefined }
+
+	const [ typeRaw, subtypeRaw ] = mimetypeRaw
+		.split(CONTENT_TYPE_SEPARATOR.SUBTYPE)
+		.map(t => t.toLowerCase())
+
+	if(typeRaw === undefined) { return undefined }
+	if(typeRaw === '') { return undefined }
+	if(hasSpecialChar(typeRaw)) { return undefined }
+	if(subtypeRaw === undefined) { return undefined }
+	if(subtypeRaw === '') { return undefined }
+	if(hasSpecialChar(subtypeRaw)) { return undefined }
+
+	const type = typeRaw.trim()
+	const subtype = subtypeRaw.trim()
+
+	const parameters = new Map()
+
+	parameterSet
+			.forEach(parameter => {
+				const [ key, value ] = parameter.split(CONTENT_TYPE_SEPARATOR.KVP)
+				if(key === undefined || key === '') { return }
+				if(value === undefined || value === '') { return }
+				if(hasSpecialChar(key)) { return }
+
+				const actualKey = key?.trim().toLowerCase()
+
+				const quoted = (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"')
+				const actualValue = quoted ? value.substring(1, value.length - 1) : value
+
+				if(!parameters.has(actualKey)) {
+					parameters.set(actualKey, actualValue)
+				}
+			})
+
+	const charset = parameters.get(CHARSET)
+
+	return {
+		mimetype: `${type}${CONTENT_TYPE_SEPARATOR.SUBTYPE}${subtype}`,
+		mimetypeRaw, type, subtype,
+		charset,
+		parameters
+	}
+}

package/src/forwarded.js

@@ -0,0 +1,145 @@
+export const FORWARDED_KEY_BY = 'by'
+export const FORWARDED_KEY_FOR = 'for'
+export const FORWARDED_KEY_HOST = 'host'
+export const FORWARDED_KEY_PROTO = 'proto'
+
+export const KNOWN_FORWARDED_KEYS = [
+	FORWARDED_KEY_BY,
+	FORWARDED_KEY_FOR,
+	FORWARDED_KEY_HOST,
+	FORWARDED_KEY_PROTO
+]
+
+export const SKIP_ANY = '*'
+
+export const FORWARDED_SEPARATOR = {
+	ITEM: ',',
+	ELEMENT: ';',
+	KVP: '='
+}
+
+export class Forwarded {
+	/**
+	 * @param {string|undefined} header
+	 * @param {Array<string>} acceptedKeys
+	 * @returns {Array<Map<string, string>>}
+	 */
+	static parse(header, acceptedKeys = KNOWN_FORWARDED_KEYS) {
+		if(typeof header !== 'string') { return [] }
+
+		return header
+			.trim()
+			.split(FORWARDED_SEPARATOR.ITEM)
+			.map(single => new Map(single
+					.trim()
+					.split(FORWARDED_SEPARATOR.ELEMENT)
+					.map(kvp => {
+						const [ rawKey, rawValue ] = kvp.trim().split(FORWARDED_SEPARATOR.KVP)
+
+						const key = rawKey?.trim()?.toLowerCase()
+						if (key === undefined || !acceptedKeys.includes(key)) { return undefined }
+
+						const value = rawValue?.trim()
+						if(value === undefined) { return undefined }
+						if(value.length <= 0) { return undefined }
+
+						/** @type {[string, string]} */
+						const result = [ key, value ]
+						return result
+					})
+					.filter(item => item !== undefined))
+			)
+			.filter(m => m.size !== 0)
+	}
+
+	/**
+	 * @param {Array<Map<string, string>>} forwardedList
+	 * @param {Array<string>} skipList list of for values starting with right-most to skip in forwarded list
+	 * @returns {Map<string, string>|undefined}
+	 */
+	static selectRightMost(forwardedList, skipList = []) {
+		const iter = skipList[Symbol.iterator]()
+
+		for(const forwarded of forwardedList.toReversed()) {
+			const forValue = forwarded.get(FORWARDED_KEY_FOR)
+			const { done, value } = iter.next()
+			if(done) { return forwarded }
+			if(value !== SKIP_ANY && value !== forValue) { return undefined }
+		}
+
+		return undefined
+	}
+}
+
+
+/*
+const examples = [
+	{ f: [], s: [], ef: undefined },
+
+	{ f: [], s: [ '1.1.1.1' ] , ef: undefined },
+	{ f: [], s: [ '*' ] , ef: undefined },
+
+	{ f: [ { for: '1.1.1.1' } ], s: [], ef: '1.1.1.1' },
+	{ f: [ { for: '1.1.1.1' } ], s: [ '*' ], ef: undefined },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' } ], s: [], ef: '2.2.2.2' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' } ], s: [ '2.2.2.2' ], ef: '1.1.1.1' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3', '2.2.2.2' ], ef: '1.1.1.1' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3', '*' ], ef: '1.1.1.1' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*', '*' ], ef: '1.1.1.1' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*', '*', '*' ], ef: undefined },
+
+	{ f: [ { for: '1.1.1.1' } ], s: [ '*', '*' ], ef: undefined },
+
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3'], ef: '2.2.2.2' },
+	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*'], ef: '2.2.2.2' },
+]
+
+for(const { f, s, ef } of examples) {
+	const result = Forwarded.selectRightMost(f.map(i => new Map(Object.entries(i))), s)
+	const resultFor = result?.get('for')
+	if(resultFor !== ef) {
+		console.log(`mismatch ${ef} !== ${resultFor}`)
+	}
+}
+*/
+
+
+/*
+	const examples = [
+		null,
+		undefined,
+		42,
+		'',
+		'			',
+		'some value here',
+		'======;;;',
+		',=,=,=;;;==,,,for',
+		'a=2, b=3, by=, =10',
+		'by=🚀',
+		'🔑="a key"',
+
+		'for="_gazonk"',
+		'for="_mdn"',
+		'For="[2001:db8:cafe::17]:4711"',
+		'for=192.0.2.60;proto=http;by=203.0.113.43',
+		'for=192.0.2.43, for=198.51.100.17',
+		'for=192.0.2.43',
+		'for=192.0.2.43, for=198.51.100.17;by=203.0.113.60;proto=http;host=example.com"',
+		'for=192.0.2.43, for="[2001:db8:cafe::17]"',
+		'for=192.0.2.43,for="[2001:db8:cafe::17]",for=unknown',
+		'for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown',
+		'for=_hidden, for=_SEVKISEK',
+		'for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown',
+
+		' for = 1.1.1.1   ,for=     2.2.2.2    ',
+		' fro=not_real, for=[::1]',
+		'FOr=192.0.2.43:47011,for="[2001:db8:cafe::17]:47011"',
+		' for=12.34.56.78, for=23.45.67.89;secret=egah2CGj55fSJFs, for=10.1.2.3'
+	]
+
+	for (const example of examples) {
+		console.log('================================')
+		console.log(example)
+		console.log(Forwarded.parse(example, [ ...KNOWN_FORWARDED_KEYS, 'secret', '🔑']))
+	}
+*/

package/src/handle-stream-util.js

@@ -0,0 +1,262 @@
+import http2 from 'node:http2'
+import { brotliCompressSync, deflateSync, gzipSync, zstdCompressSync } from 'node:zlib'
+
+import {
+	SSE_MIME,
+	SSE_INACTIVE_STATUS_CODE,
+	SSE_BOM,
+	ENDING,
+} from '@johntalton/sse-util'
+
+import { CHARSET_UTF8, CONTENT_TYPE_JSON, CONTENT_TYPE_TEXT } from './content-type.js'
+import { ServerTiming, HTTP_HEADER_SERVER_TIMING, HTTP_HEADER_TIMING_ALLOW_ORIGIN } from './server-timing.js'
+import { HTTP_HEADER_RATE_LIMIT, HTTP_HEADER_RATE_LIMIT_POLICY, RateLimit, RateLimitPolicy } from './rate-limit.js'
+
+const {
+	HTTP2_HEADER_STATUS,
+	HTTP2_HEADER_CONTENT_TYPE,
+	HTTP2_HEADER_CONTENT_ENCODING,
+	HTTP2_HEADER_VARY,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
+	HTTP2_HEADER_SERVER,
+	HTTP2_HEADER_RETRY_AFTER,
+	HTTP2_HEADER_CACHE_CONTROL
+} = http2.constants
+
+const {
+	HTTP_STATUS_OK,
+	HTTP_STATUS_NOT_FOUND,
+	HTTP_STATUS_UNAUTHORIZED,
+	HTTP_STATUS_NO_CONTENT,
+	HTTP_STATUS_INTERNAL_SERVER_ERROR,
+	HTTP_STATUS_TOO_MANY_REQUESTS
+} = http2.constants
+
+export const HTTP_HEADER_ORIGIN = 'origin'
+export const HTTP_HEADER_USER_AGENT = 'user-agent'
+export const HTTP_HEADER_FORWARDED = 'forwarded'
+export const HTTP_HEADER_SEC_CH_UA = 'sec-ch-ua'
+export const HTTP_HEADER_SEC_CH_PLATFORM = 'sec-ch-ua-platform'
+export const HTTP_HEADER_SEC_CH_MOBILE = 'sec-ch-ua-mobile'
+export const HTTP_HEADER_SEC_FETCH_SITE = 'sec-fetch-site'
+export const HTTP_HEADER_SEC_FETCH_MODE = 'sec-fetch-mode'
+export const HTTP_HEADER_SEC_FETCH_DEST = 'sec-fetch-dest'
+
+export const DEFAULT_METHODS = [ 'HEAD', 'GET', 'POST', 'PATCH', 'DELETE' ]
+
+export const HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE = 'access-control-max-age'
+export const PREFLIGHT_AGE_SECONDS = '500'
+
+/**
+ * @import { ServerHttp2Stream } from 'node:http2'
+ */
+
+/**
+ * @import { TimingsInfo } from './server-timing.js'
+ */
+
+/**
+ * @typedef {Object} Metadata
+ * @property {Array<TimingsInfo>} performance
+ * @property {string|undefined} servername
+ * @property {string|undefined} origin
+ */
+
+/**
+ * @typedef {Object} SSEOptions
+ * @property {boolean} [active]
+ * @property {boolean} [bom]
+ */
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {string} message
+ * @param {Metadata} meta
+ */
+export function sendError(stream, message, meta) {
+	console.error('500', message)
+
+	if(stream === undefined) { return }
+	if(stream.closed) { return }
+
+	if(!stream.headersSent) {
+		stream.respond({
+			[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
+			[HTTP2_HEADER_STATUS]: HTTP_STATUS_INTERNAL_SERVER_ERROR,
+			[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_TEXT,
+			[HTTP2_HEADER_SERVER]: meta.servername
+		})
+	}
+
+	// protect against HEAD calls
+	if(stream.writable) {
+		if(message !== undefined) { stream.write(message) }
+	}
+
+	stream.end()
+	if(!stream.closed) { stream.close() }
+}
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {string|undefined} allowedOrigin
+ * @param {Array<string>} methods
+ * @param {Metadata} meta
+ */
+export function sendPreflight(stream, allowedOrigin, methods, meta) {
+	stream.respond({
+		[HTTP2_HEADER_STATUS]: HTTP_STATUS_OK,
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: allowedOrigin,
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS]: methods.join(','),
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS]: ['Authorization', HTTP2_HEADER_CONTENT_TYPE].join(','),
+		[HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE]: PREFLIGHT_AGE_SECONDS,
+		[HTTP2_HEADER_SERVER]: meta.servername
+	})
+	stream.end()
+}
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Metadata} meta
+ */
+export function sendUnauthorized(stream, meta) {
+	console.log('Unauthorized')
+
+	stream.respond({
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
+		[HTTP2_HEADER_STATUS]: HTTP_STATUS_UNAUTHORIZED,
+		[HTTP2_HEADER_SERVER]: meta.servername
+	})
+	stream.end()
+}
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {string} message
+ * @param {Metadata} meta
+ */
+export function sendNotFound(stream, message, meta) {
+	console.log('404', message)
+	stream.respond({
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
+		[HTTP2_HEADER_STATUS]: HTTP_STATUS_NOT_FOUND,
+		[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_TEXT,
+		[HTTP2_HEADER_SERVER]: meta.servername
+	})
+
+	if(message !== undefined) { stream.write(message) }
+	stream.end()
+}
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {*} limitInfo
+ * @param {Array<any>} policies
+ * @param {Metadata} meta
+ */
+export function sendTooManyRequests(stream, limitInfo, policies, meta) {
+	stream.respond({
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: meta.origin,
+		[HTTP2_HEADER_STATUS]: HTTP_STATUS_TOO_MANY_REQUESTS,
+		[HTTP2_HEADER_SERVER]: meta.servername,
+
+		[HTTP2_HEADER_RETRY_AFTER]: limitInfo.retryAfterS,
+		[HTTP_HEADER_RATE_LIMIT]: RateLimit.from(limitInfo),
+		[HTTP_HEADER_RATE_LIMIT_POLICY]: RateLimitPolicy.from(...policies)
+	})
+
+	stream.write(`Retry After ${limitInfo.retryAfterS} Seconds`)
+	stream.end()
+}
+
+/**
+ * @typedef { (data: string, charset: BufferEncoding) => Buffer } EncoderFun
+ */
+
+/** @type {Map<string, EncoderFun>} */
+export const ENCODER_MAP = new Map([
+	[ 'br', (data, charset) => brotliCompressSync(Buffer.from(data, charset)) ],
+	[ 'gzip', (data, charset) => gzipSync(Buffer.from(data, charset)) ],
+	[ 'deflate', (data, charset) => deflateSync(Buffer.from(data, charset)) ],
+	[ 'zstd', (data, charset) => zstdCompressSync(Buffer.from(data, charset)) ]
+])
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {Object} obj
+ * @param {string|undefined} encoding
+ * @param {string|undefined} allowedOrigin
+ * @param {Metadata} meta
+ */
+export function sendJSON_Encoded(stream, obj, encoding, allowedOrigin, meta) {
+	if(stream.closed) { return }
+
+	const json = JSON.stringify(obj)
+
+	const useIdentity = encoding === 'identity'
+	const encoder = encoding !== undefined ? ENCODER_MAP.get(encoding) : undefined
+	const hasEncoder = encoder !== undefined
+	const actualEncoding = hasEncoder ? encoding : undefined
+
+	const encodeStart = performance.now()
+	const encodedData = hasEncoder && !useIdentity ? encoder(json, CHARSET_UTF8) : json
+	const encodeEnd = performance.now()
+
+	meta.performance.push(
+		{ name: 'encode', duration: encodeEnd - encodeStart }
+	)
+
+	stream.respond({
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: allowedOrigin,
+		[HTTP2_HEADER_CONTENT_TYPE]: CONTENT_TYPE_JSON,
+		[HTTP2_HEADER_CONTENT_ENCODING]: actualEncoding,
+		[HTTP2_HEADER_VARY]: 'Accept, Accept-Encoding',
+		[HTTP2_HEADER_CACHE_CONTROL]: 'private',
+		[HTTP2_HEADER_STATUS]: HTTP_STATUS_OK,
+		[HTTP2_HEADER_SERVER]: meta.servername,
+		[HTTP_HEADER_TIMING_ALLOW_ORIGIN]: allowedOrigin,
+		[HTTP_HEADER_SERVER_TIMING]: ServerTiming.encode(meta.performance)
+	})
+
+	// stream.write(encodedData)
+	stream.end(encodedData)
+}
+
+/**
+ * @param {ServerHttp2Stream} stream
+ * @param {string|undefined} allowedOrigin
+ * @param {SSEOptions & Metadata} meta
+ */
+export function sendSSE(stream, allowedOrigin, meta) {
+	// stream.setTimeout(0)
+	// stream.session?.setTimeout(0)
+	// stream.session?.socket.setTimeout(0)
+	// stream.session.socket.setNoDelay(true)
+	// stream.session.socket.setKeepAlive(true)
+
+	// stream.on('close', () => console.log('SSE stream closed'))
+	// stream.on('aborted', () => console.log('SSE stream aborted'))
+
+	const activeStream = meta.active ?? true
+	const sendBOM = meta.bom ?? true
+
+	stream.respond({
+		[HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN]: allowedOrigin,
+		[HTTP2_HEADER_CONTENT_TYPE]: SSE_MIME,
+		[HTTP2_HEADER_STATUS]: activeStream ? HTTP_STATUS_OK : HTTP_STATUS_NO_CONTENT, // SSE_INACTIVE_STATUS_CODE
+		// [HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS]: 'true'
+		[HTTP2_HEADER_SERVER]: meta.servername
+	 })
+
+	 if(!activeStream) {
+		stream.end()
+		return
+	 }
+
+	if(sendBOM) {
+		stream.write(SSE_BOM + ENDING.CRLF)
+	}
+}

package/src/index.js

@@ -0,0 +1,10 @@
+export * from './accept-encoding.js'
+export * from './accept-language.js'
+export * from './accept-util.js'
+export * from './accept.js'
+export * from './content-disposition.js'
+export * from './content-type.js'
+export * from './forwarded.js'
+export * from './multipart.js'
+export * from './rate-limit.js'
+export * from './server-timing.js'