@lenne.tech/ng-base 18.1.3 → 22.0.1

package/fesm2022/lenne.tech-ng-base-bug-server.mjs

@@ -0,0 +1,818 @@
+const LT_LINEAR_API_URL = "https://api.linear.app/graphql";
+const LT_BUG_LABELS = Object.freeze({
+	bug: {
+		color: "#f87171",
+		name: "bug"
+	},
+	enhancement: {
+		color: "#34d399",
+		name: "enhancement"
+	},
+	feature: {
+		color: "#60a5fa",
+		name: "feature"
+	},
+	other: {
+		color: "#a78bfa",
+		name: "other"
+	}
+});
+var LtLinearError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "LtLinearError";
+	}
+};
+const MAX_PAGES = 10;
+var LtLinearClient = class {
+	options;
+	apiUrl;
+	fetchFn;
+	timeoutMs;
+	constructor(options) {
+		this.options = options;
+		this.apiUrl = options.apiUrl ?? "https://api.linear.app/graphql";
+		this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.timeoutMs = options.timeoutMs ?? 15e3;
+	}
+	async request(query, variables = {}) {
+		let response;
+		try {
+			response = await this.fetchFn(this.apiUrl, {
+				body: JSON.stringify({
+					query,
+					variables
+				}),
+				headers: {
+					Authorization: this.options.apiKey,
+					"Content-Type": "application/json"
+				},
+				method: "POST",
+				signal: AbortSignal.timeout(this.timeoutMs)
+			});
+		} catch (error) {
+			throw new LtLinearError(`Linear API request failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new LtLinearError(`Linear API request failed: ${response.status} ${response.statusText} - ${text.slice(0, 500)}`, response.status);
+		}
+		const result = await response.json().catch(() => null);
+		if (!result) throw new LtLinearError("Linear API answered with invalid JSON");
+		if (result.errors?.length) throw new LtLinearError(`Linear GraphQL error: ${JSON.stringify(result.errors).slice(0, 1e3)}`);
+		return result.data;
+	}
+	async getTeams() {
+		return this.collect("query Teams($after: String) { teams(first: 250, after: $after) { nodes { id name key } pageInfo { hasNextPage endCursor } } }", (data) => data.teams);
+	}
+	async findTeam(nameOrKey) {
+		const wanted = nameOrKey.trim().toLowerCase();
+		return (await this.getTeams()).find((team) => team.name.toLowerCase() === wanted || team.key.toLowerCase() === wanted) ?? null;
+	}
+	async findProject(name) {
+		const wanted = name.trim().toLowerCase();
+		return (await this.collect("query Projects($after: String) { projects(first: 250, after: $after) { nodes { id name } pageInfo { hasNextPage endCursor } } }", (data) => data.projects)).find((project) => project.name.toLowerCase() === wanted) ?? null;
+	}
+	async findLabel(teamId, name) {
+		const wanted = name.toLowerCase();
+		const matches = (await this.collect("query Labels($after: String) { issueLabels(first: 250, after: $after) { nodes { id name team { id } } pageInfo { hasNextPage endCursor } } }", (data) => data.issueLabels)).filter((label) => label.name.toLowerCase() === wanted && (!label.team || label.team.id === teamId));
+		return (matches.find((label) => label.team?.id === teamId) ?? matches[0])?.id ?? null;
+	}
+	async createLabel(teamId, name, color) {
+		const data = await this.request("mutation CreateLabel($input: IssueLabelCreateInput!) { issueLabelCreate(input: $input) { success issueLabel { id name } } }", { input: {
+			color,
+			name,
+			teamId
+		} });
+		return data.issueLabelCreate?.success ? data.issueLabelCreate.issueLabel?.id ?? null : null;
+	}
+	async createIssue(input) {
+		const payload = {
+			description: input.description,
+			teamId: input.teamId,
+			title: input.title
+		};
+		if (input.projectId) payload["projectId"] = input.projectId;
+		if (input.labelIds?.length) payload["labelIds"] = input.labelIds;
+		const data = await this.request("mutation CreateIssue($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id url identifier title } } }", { input: payload });
+		if (!data.issueCreate?.success || !data.issueCreate.issue?.id) throw new LtLinearError("Linear did not create the issue");
+		return data.issueCreate.issue;
+	}
+	async uploadFile(content, filename, contentType) {
+		if (!content.length) throw new LtLinearError(`File ${filename} has zero size`);
+		const data = await this.request("mutation FileUpload($contentType: String!, $filename: String!, $size: Int!) { fileUpload(contentType: $contentType, filename: $filename, size: $size) { success uploadFile { uploadUrl assetUrl headers { key value } } } }", {
+			contentType,
+			filename,
+			size: content.length
+		});
+		const upload = data.fileUpload?.uploadFile;
+		if (!data.fileUpload?.success || !upload?.uploadUrl || !upload.assetUrl) throw new LtLinearError("Failed to get upload URL from Linear");
+		if (!/^https:\/\//i.test(upload.uploadUrl)) throw new LtLinearError("Linear returned a non-HTTPS upload URL");
+		const headers = new Headers({ "Content-Type": contentType });
+		for (const { key, value } of upload.headers ?? []) headers.set(key, value);
+		let response;
+		try {
+			const body = new Uint8Array(content.byteLength);
+			body.set(content);
+			response = await this.fetchFn(upload.uploadUrl, {
+				body,
+				headers,
+				method: "PUT",
+				signal: AbortSignal.timeout(this.timeoutMs * 4)
+			});
+		} catch (error) {
+			throw new LtLinearError(`Failed to upload file: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!response.ok) throw new LtLinearError(`Failed to upload file: ${response.status} ${response.statusText}`, response.status);
+		return upload.assetUrl;
+	}
+	async createAttachment(issueId, url, title) {
+		const data = await this.request("mutation CreateAttachment($input: AttachmentCreateInput!) { attachmentCreate(input: $input) { success attachment { id } } }", { input: {
+			issueId,
+			title,
+			url
+		} });
+		return data.attachmentCreate?.success ? data.attachmentCreate.attachment?.id ?? null : null;
+	}
+	async collect(query, pick) {
+		const items = [];
+		let after = null;
+		for (let page = 0; page < MAX_PAGES; page++) {
+			const connection = pick(await this.request(query, { after }));
+			items.push(...connection?.nodes ?? []);
+			if (!connection?.pageInfo?.hasNextPage || !connection.pageInfo.endCursor) break;
+			after = connection.pageInfo.endCursor;
+		}
+		return items;
+	}
+};
+function formatLtBugReportForLinear(report, options = {}) {
+	const timeZone = options.timeZone ?? "Europe/Berlin";
+	const sections = [];
+	const reportParts = [`**Beschreibung:**\n${report.description}`];
+	if (report.expectedBehavior) reportParts.push(`**Erwartetes Verhalten:**\n${report.expectedBehavior}`);
+	if (report.stepsToReproduce) reportParts.push(`**Schritte zur Reproduktion:**\n${report.stepsToReproduce}`);
+	sections.push(`## Bug Report\n\n${reportParts.join("\n\n")}`);
+	const info = report.browserInfo;
+	if (info) {
+		const browser = `${info.browser?.name || "Unknown"} ${info.browser?.version || ""}`.trim();
+		const os = `${info.os?.name || info.platform || "Unknown"} ${info.os?.version || ""}`.trim();
+		sections.push([
+			"---",
+			"",
+			"## Kontext",
+			"",
+			"| | |",
+			"|---|---|",
+			`| **URL** | ${cell(info.url ?? "")} |`,
+			`| **Browser** | ${cell(browser)} |`,
+			`| **OS** | ${cell(os)} |`,
+			`| **Viewport** | ${info.viewport ? `${info.viewport.width}x${info.viewport.height}` : ""} |`,
+			`| **Zeitpunkt** | ${cell(info.timestamp ?? "")} |`
+		].join("\n"));
+	}
+	if (report.userInteractions.length) {
+		const rows = report.userInteractions.map((event) => `| ${time(event.timestamp, timeZone)} | ${cell(eventType(event.type))} | ${cell(shorten(event.target, 40))} | ${cell(eventDetails(event))} |`);
+		sections.push([
+			"---",
+			"",
+			"## User Journey",
+			"",
+			`> Letzte ${report.userInteractions.length} Aktionen vor dem Bug`,
+			"",
+			"| Zeit | Aktion | Element | Details |",
+			"|------|--------|---------|---------|",
+			...rows
+		].join("\n"));
+	}
+	const technical = [];
+	if (report.consoleLogs.length) {
+		const logs = report.consoleLogs.slice(-10);
+		const lines = logs.map((log) => `[${log.timestamp}] ${log.level.toUpperCase()}: ${log.message.join(" ")}`.replace(/```/g, "`​``"));
+		technical.push(`### Console Logs (${logs.length})\n\n\`\`\`\n${lines.join("\n")}\n\`\`\``);
+	}
+	if (report.networkRequests.length) {
+		const requests = report.networkRequests.slice(-10);
+		const failed = requests.filter((request) => request.status >= 400 || request.status === 0);
+		let content = [
+			"| Method | URL | Status |",
+			"|--------|-----|--------|",
+			...requests.map((request) => `| ${cell(request.method)} | ${cell(shorten(request.url, 60))} | ${request.status === 0 ? "ERR" : request.status} |`)
+		].join("\n");
+		if (failed.length) {
+			const lines = failed.map((request) => {
+				const reason = request.status === 0 ? request.error || request.statusText : `${request.status} ${request.statusText}`.trim();
+				const body = request.responseBody ? `\n  \`${shorten(request.responseBody, 200).replace(/`/g, "'").replace(/\s+/g, " ")}\`` : "";
+				return `- ${request.method} ${request.url.slice(0, 60)} → ${reason}${body}`;
+			});
+			content += `\n\n**Fehlerhafte Requests:**\n${lines.join("\n")}`;
+		}
+		technical.push(`### Network Requests (${requests.length})\n\n${content}`);
+	}
+	if (technical.length) sections.push(`---\n\n## Technische Details\n\n${technical.join("\n\n")}`);
+	const notes = [];
+	if (report.attachments.length) {
+		const screenshots = report.attachments.filter((file) => file.isScreenshot).length;
+		const others = report.attachments.length - screenshots;
+		notes.push(screenshots && others ? `*${screenshots} Screenshot(s) und ${others} weitere Anhänge*` : screenshots ? `*${screenshots} Screenshot(s) angehängt*` : `*${others} Anhänge*`);
+	}
+	if (report.skippedAttachments) notes.push(`*${report.skippedAttachments} Anhang/Anhänge nicht übernommen (zu groß oder zu viele)*`);
+	if (notes.length) sections.push(`---\n\n${notes.join("\n\n")}`);
+	return {
+		description: sections.join("\n\n"),
+		title: `${report.type.toUpperCase()}: ${report.title}`
+	};
+}
+function cell(value) {
+	return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\s*[\r\n]+\s*/g, " ");
+}
+function shorten(value, max) {
+	return value.length > max ? `${value.slice(0, max - 3)}...` : value;
+}
+function eventType(type) {
+	return type.replace(/_/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function time(timestamp, timeZone) {
+	const date = new Date(timestamp);
+	if (Number.isNaN(date.getTime())) return "";
+	try {
+		return date.toLocaleTimeString("de-DE", {
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			timeZone
+		});
+	} catch {
+		return date.toISOString().slice(11, 19);
+	}
+}
+function eventDetails(event) {
+	const metadata = event.metadata;
+	if (!metadata) return "";
+	if (metadata.toUrl) return `→ ${metadata.toUrl.slice(0, 50)}`;
+	if (metadata.text) return metadata.text.slice(0, 40);
+	if (metadata.errorMessage) return `Error: ${metadata.errorMessage.slice(0, 40)}`;
+	if (metadata.key) return `Key: ${metadata.key}`;
+	return "";
+}
+const LT_BUG_REDACTED = "[redacted]";
+const LT_BUG_SENSITIVE_HEADERS = Object.freeze([
+	"api-key",
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"set-cookie",
+	"x-access-token",
+	"x-api-key",
+	"x-auth-token",
+	"x-csrf-token",
+	"x-system-setup-token",
+	"x-xsrf-token"
+]);
+const LT_BUG_BODY_EXCLUDED_SEGMENTS = Object.freeze([
+	"auth",
+	"iam",
+	"login",
+	"logout",
+	"oauth",
+	"oauth2",
+	"passkey",
+	"reset-password",
+	"sign-in",
+	"sign-up",
+	"signin",
+	"signup",
+	"system-setup",
+	"token",
+	"two-factor",
+	"verify-email"
+]);
+const SENSITIVE_KEY_PARTS = [
+	"apikey",
+	"authorization",
+	"backupcode",
+	"cardnumber",
+	"cookie",
+	"credential",
+	"creditcard",
+	"passwd",
+	"password",
+	"privatekey",
+	"recoverycode",
+	"secret",
+	"signature",
+	"token",
+	"totp",
+	"twofactor",
+	"verificationcode"
+];
+const SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+	"auth",
+	"code",
+	"csc",
+	"cvc",
+	"cvv",
+	"iban",
+	"jwt",
+	"otp",
+	"pin",
+	"pwd",
+	"sessionid",
+	"sid",
+	"ssn"
+]);
+const SENSITIVE_HEADER_SET = new Set(LT_BUG_SENSITIVE_HEADERS);
+const BODY_EXCLUDED = new RegExp(`/(?:${LT_BUG_BODY_EXCLUDED_SEGMENTS.map((segment) => segment.replace(/[-/]/g, "\\$&")).join("|")})(?:[/?#;]|$)`, "i");
+const USERINFO = /\b([a-z][a-z\d+.-]*:\/\/)[^\s/?#@:]+:[^\s/?#@]+@/gi;
+const JWT = /\beyJ[\w-]{5,}\.[\w-]{5,}\.[\w-]*/g;
+const BEARER = /\b(Bearer)\s+(?=[\w\-.~+/]*[\d.\-_~+/])[\w\-.~+/]{8,}=*/g;
+const PATH_TOKEN = /(\/(?:activate|confirm-email|email-verification|invitation|invite|magic-link|reset-password|verify-email)\/)[^/?#\s"'<>]+/gi;
+const PARAM = /(^|[?&#;\s"'(,{]|%3[fF]|%26|%23)((?:[\w.\-~[\]]|%5[bBdD])+)(=|%3[dD])([^&#;\s"'<>)}]*?)(?=$|[&#;\s"'<>)}]|%26|%23)/g;
+const JSON_PAIR = /("((?:[^"\\]|\\.)*)"\s*:\s*)("(?:[^"\\]|\\.)*"|-?\d[\d.eE+-]*|true|false|null)/g;
+const JSON_PAIR_OPEN = /("((?:[^"\\]|\\.)*)"\s*:\s*)"(?:[^"\\]|\\.)*$/;
+const LABELLED = /\b(api[-_]?key|otp|passwd|password|secret|token)(\s*:\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi;
+function isLtSensitiveHeader(name) {
+	return SENSITIVE_HEADER_SET.has(name.trim().toLowerCase());
+}
+function isLtSensitiveKey(key) {
+	const decoded = safeDecode(key);
+	const normalized = (decoded.split(/[[\].]/).filter(Boolean).pop() ?? decoded).toLowerCase().replace(/[-_\s]/g, "");
+	return SENSITIVE_KEYS.has(normalized) || SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part));
+}
+function isLtBodyExcludedUrl(url) {
+	const path = url.replace(/^[a-z][a-z\d+.-]*:\/\/[^/?#]*/i, "").split(/[?#]/)[0] ?? "";
+	return BODY_EXCLUDED.test(path);
+}
+function redactLtText(text) {
+	if (!text) return text;
+	let result = text.replace(USERINFO, `$1${LT_BUG_REDACTED}@`).replace(JWT, LT_BUG_REDACTED).replace(BEARER, `$1 ${LT_BUG_REDACTED}`).replace(PATH_TOKEN, `$1${LT_BUG_REDACTED}`);
+	result = redactParams(result, 0);
+	result = result.replace(JSON_PAIR, (match, prefix, key) => isLtSensitiveKey(key) ? `${prefix}"${LT_BUG_REDACTED}"` : match);
+	result = result.replace(JSON_PAIR_OPEN, (match, prefix, key) => isLtSensitiveKey(key) ? `${prefix}"${LT_BUG_REDACTED}"` : match);
+	return result.replace(LABELLED, `$1$2${LT_BUG_REDACTED}`);
+}
+function redactLtUrl(url) {
+	return redactLtText(url);
+}
+function redactLtValue(value, depth = 0) {
+	if (typeof value === "string") return redactLtText(value);
+	if (depth > 20 || value === null || typeof value !== "object") return depth > 20 ? LT_BUG_REDACTED : value;
+	if (Array.isArray(value)) return value.map((item) => redactLtValue(item, depth + 1));
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = isLtSensitiveKey(key) ? LT_BUG_REDACTED : redactLtValue(item, depth + 1);
+	return result;
+}
+function redactLtBody(body, maxLength = 1e3) {
+	const input = body.length > 2e4 ? body.slice(0, 2e4) : body;
+	const trimmed = input.trim();
+	let redacted;
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) try {
+		redacted = JSON.stringify(redactLtValue(JSON.parse(trimmed)));
+	} catch {
+		redacted = redactLtText(input);
+	}
+	else redacted = redactLtText(input);
+	return truncateLt(redacted, maxLength);
+}
+function redactLtHeaders(headers) {
+	const result = {};
+	for (const [name, value] of Object.entries(headers)) result[name] = isLtSensitiveHeader(name) ? LT_BUG_REDACTED : redactLtText(String(value));
+	return result;
+}
+function truncateLt(text, maxLength) {
+	return text.length <= maxLength ? text : `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} characters]`;
+}
+function redactParams(text, depth) {
+	return text.replace(PARAM, (match, separator, key, equals, value) => {
+		if (isLtSensitiveKey(key)) return `${separator}${key}${equals}${value ? LT_BUG_REDACTED : ""}`;
+		if (depth < 3 && /=|%3[dD]/.test(value)) return `${separator}${key}${equals}${redactParams(value, depth + 1)}`;
+		return match;
+	});
+}
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+const LT_BUG_REPORT_TYPES = [
+	"bug",
+	"feature",
+	"enhancement",
+	"other"
+];
+const LT_BUG_REPORT_LIMITS = Object.freeze({
+	attachments: 10,
+	attachmentDataUrl: 15e6,
+	consoleLogs: 100,
+	description: 2e4,
+	networkRequests: 100,
+	text: 1e4,
+	title: 255,
+	userInteractions: 200
+});
+const LT_BUG_MISSING_FIELDS = "Missing required fields: title, type, and description are required";
+const DATA_URL = /^data:([\w.+-]+\/[\w.+-]+)?((?:;[\w.+-]+=[^;,]*)*);base64,/i;
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+const MIME = /^[\w.+-]+\/[\w.+-]+$/;
+function validateLtBugReport(body) {
+	if (!isRecord(body)) return invalid("The bug report must be a JSON object");
+	const title = typeof body["title"] === "string" ? body["title"].trim() : "";
+	const description = typeof body["description"] === "string" ? body["description"].trim() : "";
+	const type = body["type"];
+	if (!title || !description || typeof type !== "string" || !type) return invalid(LT_BUG_MISSING_FIELDS);
+	if (!LT_BUG_REPORT_TYPES.includes(type)) return invalid(`type must be one of ${LT_BUG_REPORT_TYPES.join(", ")}`);
+	for (const key of [
+		"expectedBehavior",
+		"stepsToReproduce",
+		"screenshot"
+	]) if (body[key] !== void 0 && body[key] !== null && typeof body[key] !== "string") return invalid(`${key} must be a string`);
+	for (const key of [
+		"attachments",
+		"consoleLogs",
+		"networkRequests",
+		"userInteractions"
+	]) if (body[key] !== void 0 && body[key] !== null && !Array.isArray(body[key])) return invalid(`${key} must be an array`);
+	if (body["browserInfo"] !== void 0 && body["browserInfo"] !== null && !isRecord(body["browserInfo"])) return invalid("browserInfo must be an object");
+	const files = [];
+	let skippedAttachments = 0;
+	const rawAttachments = body["attachments"] ?? [];
+	for (const [index, raw] of rawAttachments.entries()) {
+		if (!isRecord(raw) || typeof raw["data"] !== "string") return invalid(`attachments[${index}] needs a data URL`);
+		const file = decodeDataUrl(raw["data"], typeof raw["type"] === "string" ? raw["type"] : void 0);
+		if (file === "invalid") return invalid(`attachments[${index}] is not a base64 data URL`);
+		if (file === "too-large" || files.length >= LT_BUG_REPORT_LIMITS.attachments || file.data.length === 0) {
+			skippedAttachments++;
+			continue;
+		}
+		files.push({
+			...file,
+			isScreenshot: raw["isScreenshot"] === true,
+			name: fileName(raw["name"], index)
+		});
+	}
+	const screenshot = typeof body["screenshot"] === "string" && body["screenshot"] ? body["screenshot"] : void 0;
+	if (screenshot && !files.some((file) => file.isScreenshot)) {
+		const file = decodeDataUrl(screenshot, void 0);
+		if (file === "invalid" || file !== "too-large" && !file.contentType.startsWith("image/")) return invalid("screenshot is not a base64 image data URL");
+		if (file === "too-large" || files.length >= LT_BUG_REPORT_LIMITS.attachments) skippedAttachments++;
+		else files.push({
+			...file,
+			isScreenshot: true,
+			name: `screenshot-${Date.now()}.png`
+		});
+	}
+	return {
+		ok: true,
+		report: {
+			attachments: files,
+			browserInfo: browserInfo(body["browserInfo"]),
+			consoleLogs: newest(body["consoleLogs"], LT_BUG_REPORT_LIMITS.consoleLogs).flatMap(consoleLog),
+			description: cleanText(description, LT_BUG_REPORT_LIMITS.description),
+			expectedBehavior: optionalText(body["expectedBehavior"]),
+			networkRequests: newest(body["networkRequests"], LT_BUG_REPORT_LIMITS.networkRequests).flatMap(networkRequest),
+			skippedAttachments,
+			stepsToReproduce: optionalText(body["stepsToReproduce"]),
+			title: cleanText(title, LT_BUG_REPORT_LIMITS.title).replace(/\s+/g, " "),
+			type,
+			userInteractions: newest(body["userInteractions"], LT_BUG_REPORT_LIMITS.userInteractions).flatMap(interaction)
+		}
+	};
+}
+function invalid(error) {
+	return {
+		error,
+		ok: false
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function newest(value, limit) {
+	return Array.isArray(value) ? value.slice(-limit) : [];
+}
+function cleanText(text, max) {
+	return truncateLt(redactLtText(text.length > max * 2 ? text.slice(0, max * 2) : text), max);
+}
+function optionalText(value) {
+	return typeof value === "string" && value.trim() ? cleanText(value.trim(), LT_BUG_REPORT_LIMITS.text) : void 0;
+}
+function str(value, max) {
+	return typeof value === "string" ? cleanText(value, max) : void 0;
+}
+function num(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function decodeDataUrl(dataUrl, declaredType) {
+	const header = DATA_URL.exec(dataUrl.slice(0, 300));
+	if (!header) return "invalid";
+	if (dataUrl.length > LT_BUG_REPORT_LIMITS.attachmentDataUrl) return "too-large";
+	const payload = dataUrl.slice(header[0].length);
+	if (!BASE64.test(payload)) return "invalid";
+	const fromUrl = header[1]?.toLowerCase();
+	return {
+		contentType: declaredType && MIME.test(declaredType) ? declaredType.toLowerCase() : fromUrl && MIME.test(fromUrl) ? fromUrl : "application/octet-stream",
+		data: Buffer.from(payload, "base64")
+	};
+}
+function fileName(value, index) {
+	const base = (typeof value === "string" ? value : "").split(/[/\\]/).pop() ?? "";
+	return (Array.from(base).filter((char) => char.charCodeAt(0) >= 32 && char.charCodeAt(0) !== 127).join("").trim() || `attachment-${index + 1}`).slice(0, 200);
+}
+function browserInfo(value) {
+	if (!isRecord(value)) return;
+	const pair = (source) => isRecord(source) ? {
+		name: str(source["name"], 100),
+		version: str(source["version"], 100)
+	} : void 0;
+	const viewport = isRecord(value["viewport"]) ? {
+		height: num(value["viewport"]["height"]) ?? 0,
+		width: num(value["viewport"]["width"]) ?? 0
+	} : void 0;
+	return {
+		browser: pair(value["browser"]),
+		language: str(value["language"], 50),
+		os: pair(value["os"]),
+		platform: str(value["platform"], 100),
+		timestamp: str(value["timestamp"], 50),
+		url: typeof value["url"] === "string" ? truncateLt(redactLtUrl(value["url"].slice(0, 4e3)), 2e3) : void 0,
+		userAgent: str(value["userAgent"], 500),
+		viewport
+	};
+}
+function consoleLog(value) {
+	if (!isRecord(value)) return [];
+	const parts = Array.isArray(value["message"]) ? value["message"] : [value["message"]];
+	return [{
+		level: [
+			"debug",
+			"error",
+			"info",
+			"log",
+			"warn"
+		].includes(String(value["level"])) ? String(value["level"]) : "log",
+		message: parts.slice(0, 20).map((part) => str(typeof part === "string" ? part : String(part ?? ""), 2e3) ?? "").filter(Boolean),
+		stack: str(value["stack"], 5e3),
+		timestamp: str(value["timestamp"], 50) ?? ""
+	}];
+}
+function networkRequest(value) {
+	if (!isRecord(value)) return [];
+	const url = typeof value["url"] === "string" ? value["url"].slice(0, 4e3) : "";
+	const responseBody = typeof value["responseBody"] === "string" && !isLtBodyExcludedUrl(url) ? redactLtBody(value["responseBody"], 1e3) : void 0;
+	return [{
+		error: str(value["error"], 500),
+		method: (str(value["method"], 16) ?? "GET").toUpperCase(),
+		responseBody,
+		status: num(value["status"]) ?? 0,
+		statusText: str(value["statusText"], 200) ?? "",
+		timestamp: str(value["timestamp"], 50) ?? "",
+		url: truncateLt(redactLtUrl(url), 2e3)
+	}];
+}
+function interaction(value) {
+	if (!isRecord(value)) return [];
+	const metadata = isRecord(value["metadata"]) ? value["metadata"] : void 0;
+	return [{
+		metadata: metadata ? {
+			errorMessage: str(metadata["errorMessage"], 500),
+			key: str(metadata["key"], 50),
+			text: str(metadata["text"], 500),
+			toUrl: str(metadata["toUrl"], 2e3),
+			url: str(metadata["url"], 2e3),
+			value: str(metadata["value"], 500)
+		} : void 0,
+		target: str(value["target"], 200) ?? "",
+		timestamp: str(value["timestamp"], 50) ?? "",
+		type: str(value["type"], 50) ?? "click"
+	}];
+}
+const LT_BUG_SERVER_DEFAULT_ENDPOINT = "/_bug-lt/report";
+const LT_BUG_DEFAULT_MAX_BODY_BYTES = 31457280;
+const PREFIX = "[@lenne.tech/ng-base/bug/server]";
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+function isLtBugServerEnabled(enabled, env) {
+	const switchValue = env["NG_PUBLIC_LT_BUG_ENABLED"]?.trim() ?? "";
+	if (/^(true|1|yes|on)$/i.test(switchValue)) return true;
+	if (/^(false|0|no|off)$/i.test(switchValue)) return false;
+	if (typeof enabled === "boolean") return enabled;
+	const appEnv = env["NG_PUBLIC_APP_ENV"]?.trim().toLowerCase();
+	return !!appEnv && appEnv !== "production" && appEnv !== "prod";
+}
+function ltBugReport(options = {}) {
+	const endpoint = options.endpoint ?? "/_bug-lt/report";
+	const limiter = createRateLimiter(options.rateLimit === void 0 ? {
+		max: 20,
+		windowMs: 6e5
+	} : options.rateLimit);
+	const logger = options.logger ?? console;
+	return (req, res, next) => {
+		if ((req.url ?? "").split("?")[0] !== endpoint) {
+			next();
+			return;
+		}
+		const env = options.env ?? processEnv();
+		if (!isLtBugServerEnabled(options.enabled, env)) {
+			sendJson(res, 404, {
+				error: "Not Found",
+				success: false
+			});
+			return;
+		}
+		handle(req, res, env, options, limiter).catch((error) => {
+			const status = error instanceof HttpError ? error.status : 500;
+			if (!(error instanceof HttpError)) logger.error(`${PREFIX} Unexpected error:`, sanitize(error, linearConfig(env, options)?.apiKey));
+			if (!res.headersSent) sendJson(res, status, {
+				error: error instanceof HttpError ? error.message : "Internal server error while processing bug report",
+				success: false
+			});
+		});
+	};
+}
+async function handle(req, res, env, options, limiter) {
+	const logger = options.logger ?? console;
+	if (req.method !== "POST") {
+		res.setHeader("allow", "POST");
+		throw new HttpError(405, "Method Not Allowed");
+	}
+	if (!/^application\/json\b/i.test(headerValue(req.headers["content-type"]) ?? "")) throw new HttpError(415, "Content-Type must be application/json");
+	const retryAfter = limiter(clientKey(req));
+	if (retryAfter > 0) {
+		res.setHeader("retry-after", String(Math.ceil(retryAfter / 1e3)));
+		throw new HttpError(429, "Too many bug reports, please try again later");
+	}
+	const config = linearConfig(env, options);
+	if (!config) {
+		const missing = [!pick(env, "NG_LINEAR_API_KEY", options.linearApiKey) && "NG_LINEAR_API_KEY", !pick(env, "NG_LINEAR_TEAM_NAME", options.linearTeamName) && "NG_LINEAR_TEAM_NAME"].filter(Boolean);
+		logger.error(`${PREFIX} Linear is not configured: set ${missing.join(" and ")} on the server.`);
+		throw new HttpError(500, "Bug reporting is not configured on the server");
+	}
+	const validation = validateLtBugReport(await readJsonBody(req, options.maxBodyBytes ?? 31457280));
+	if (!validation.ok) throw new HttpError(400, validation.error);
+	let result;
+	try {
+		result = await createLtLinearIssue(validation.report, config, {
+			fetch: options.fetch,
+			logger,
+			timeZone: options.timeZone
+		});
+	} catch (error) {
+		if (error instanceof LtBugConfigError) {
+			logger.error(`${PREFIX} ${sanitize(error, config.apiKey)}`);
+			throw new HttpError(500, "Bug reporting is not configured on the server");
+		}
+		logger.error(`${PREFIX} Linear rejected the bug report:`, sanitize(error, config.apiKey));
+		throw new HttpError(502, "Linear rejected the bug report");
+	}
+	sendJson(res, 200, {
+		identifier: result.identifier,
+		issueId: result.issueId,
+		issueUrl: result.issueUrl,
+		message: "Bug report submitted successfully",
+		success: true
+	});
+}
+var LtBugConfigError = class extends Error {};
+async function createLtLinearIssue(report, config, options = {}) {
+	const logger = options.logger ?? console;
+	const client = new LtLinearClient({
+		apiKey: config.apiKey,
+		fetch: options.fetch
+	});
+	const team = await client.findTeam(config.teamName);
+	if (!team) {
+		const available = (await client.getTeams().catch(() => [])).map((candidate) => candidate.name).join(", ");
+		throw new LtBugConfigError(`Linear team "${config.teamName}" not found (NG_LINEAR_TEAM_NAME). Available teams: ${available || "none"}`);
+	}
+	let projectId;
+	if (config.projectName) try {
+		projectId = (await client.findProject(config.projectName))?.id;
+		if (!projectId) logger.warn(`${PREFIX} Linear project "${config.projectName}" not found (NG_LINEAR_PROJECT_NAME); creating the issue without project.`);
+	} catch (error) {
+		logger.warn(`${PREFIX} Could not resolve the Linear project, continuing without:`, sanitize(error, config.apiKey));
+	}
+	let labelId = null;
+	const label = LT_BUG_LABELS[report.type];
+	if (label) try {
+		labelId = await client.findLabel(team.id, label.name) ?? await client.createLabel(team.id, label.name, label.color);
+	} catch (error) {
+		logger.warn(`${PREFIX} Could not find or create the label "${label.name}", continuing without:`, sanitize(error, config.apiKey));
+	}
+	const text = formatLtBugReportForLinear(report, { timeZone: options.timeZone });
+	const issue = await client.createIssue({
+		...text,
+		labelIds: labelId ? [labelId] : void 0,
+		projectId,
+		teamId: team.id
+	});
+	for (const file of report.attachments) try {
+		const assetUrl = await client.uploadFile(file.data, file.name, file.contentType);
+		await client.createAttachment(issue.id, assetUrl, file.name);
+	} catch (error) {
+		logger.warn(`${PREFIX} Could not upload the attachment "${file.name}", continuing without:`, sanitize(error, config.apiKey));
+	}
+	return {
+		identifier: issue.identifier,
+		issueId: issue.id,
+		issueUrl: issue.url
+	};
+}
+function linearConfig(env, options) {
+	const apiKey = pick(env, "NG_LINEAR_API_KEY", options.linearApiKey);
+	const teamName = pick(env, "NG_LINEAR_TEAM_NAME", options.linearTeamName);
+	if (!apiKey || !teamName) return null;
+	return {
+		apiKey,
+		projectName: pick(env, "NG_LINEAR_PROJECT_NAME", options.linearProjectName),
+		teamName
+	};
+}
+function pick(env, name, fallback) {
+	return env[name]?.trim() || fallback?.trim() || void 0;
+}
+function sanitize(error, apiKey) {
+	let text = error instanceof Error ? error.message : String(error);
+	if (apiKey) text = text.split(apiKey).join(LT_BUG_REDACTED);
+	return redactLtText(text.replace(/lin_api_[A-Za-z0-9]+/g, LT_BUG_REDACTED));
+}
+async function readJsonBody(req, limit) {
+	const parsed = req.body;
+	if (parsed !== void 0 && parsed !== null && typeof parsed === "object" && !Buffer.isBuffer(parsed)) return parsed;
+	if (Number(headerValue(req.headers["content-length"]) ?? 0) > limit) {
+		req.resume();
+		throw new HttpError(413, "Bug report too large");
+	}
+	const text = await new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		let tooLarge = false;
+		req.on("data", (chunk) => {
+			if (tooLarge) return;
+			size += chunk.length;
+			if (size > limit) {
+				tooLarge = true;
+				chunks.length = 0;
+				reject(new HttpError(413, "Bug report too large"));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (!tooLarge) resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+		req.on("error", (error) => reject(error));
+	});
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new HttpError(400, "The bug report must be valid JSON");
+	}
+}
+function createRateLimiter(limit) {
+	if (!limit) return () => 0;
+	const windows = /* @__PURE__ */ new Map();
+	return (key) => {
+		const now = Date.now();
+		if (windows.size > 5e3) {
+			for (const [entryKey, entry] of windows) if (entry.resetAt <= now) windows.delete(entryKey);
+		}
+		const entry = windows.get(key);
+		if (!entry || entry.resetAt <= now) {
+			windows.set(key, {
+				count: 1,
+				resetAt: now + limit.windowMs
+			});
+			return 0;
+		}
+		entry.count++;
+		return entry.count > limit.max ? entry.resetAt - now : 0;
+	};
+}
+function clientKey(req) {
+	return headerValue(req.headers["x-forwarded-for"])?.split(",").pop()?.trim() || req.socket?.remoteAddress || "unknown";
+}
+function sendJson(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json; charset=utf-8");
+	res.setHeader("cache-control", "no-store");
+	res.setHeader("x-content-type-options", "nosniff");
+	res.end(JSON.stringify(body));
+}
+function headerValue(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+function processEnv() {
+	return globalThis.process?.env ?? {};
+}
+export { LT_BUG_BODY_EXCLUDED_SEGMENTS, LT_BUG_DEFAULT_MAX_BODY_BYTES, LT_BUG_LABELS, LT_BUG_MISSING_FIELDS, LT_BUG_REDACTED, LT_BUG_REPORT_LIMITS, LT_BUG_REPORT_TYPES, LT_BUG_SENSITIVE_HEADERS, LT_BUG_SERVER_DEFAULT_ENDPOINT, LT_LINEAR_API_URL, LtBugConfigError, LtLinearClient, LtLinearError, createLtLinearIssue, formatLtBugReportForLinear, isLtBodyExcludedUrl, isLtBugServerEnabled, isLtSensitiveHeader, isLtSensitiveKey, ltBugReport, redactLtBody, redactLtHeaders, redactLtText, redactLtUrl, validateLtBugReport };
+
+//# sourceMappingURL=lenne.tech-ng-base-bug-server.mjs.map