@simon_he/vue-tui 1.0.2 → 1.1.1

package/dist/frame-perf-BBhE-iuS.js

@@ -0,0 +1,111 @@
+//#region src/observability/frame-perf.ts
+const FRAME_PERF_REASON_PRIORITY = {
+	unknown: 0,
+	manual: 1,
+	data: 2,
+	selection: 3,
+	stream: 4,
+	resize: 5,
+	scroll: 6,
+	input: 7
+};
+const EMPTY_METRIC_STATS = Object.freeze({
+	avg: 0,
+	max: 0,
+	min: 0
+});
+function metricStats(values) {
+	if (!values.length) return EMPTY_METRIC_STATS;
+	let sum = 0;
+	let max = Number.NEGATIVE_INFINITY;
+	let min = Number.POSITIVE_INFINITY;
+	for (const value of values) {
+		sum += value;
+		if (value > max) max = value;
+		if (value < min) min = value;
+	}
+	return {
+		avg: sum / values.length,
+		max,
+		min
+	};
+}
+function summarizeFramePerf(samples) {
+	const durationMs = [];
+	const renderManagerMs = [];
+	const commitMs = [];
+	const domFlushMs = [];
+	const stdoutFlushMs = [];
+	const dirtyRows = [];
+	const scannedNodes = [];
+	const paintedNodes = [];
+	const reasons = {};
+	const activePlanes = {};
+	let fullDirtyFrames = 0;
+	let coalescedInvalidates = 0;
+	let coalescedFrameTasks = 0;
+	let droppedUpdates = 0;
+	let maxQueueDepth = 0;
+	let rowBucketFallbacks = 0;
+	for (const sample of samples) {
+		durationMs.push(sample.durationMs);
+		renderManagerMs.push(sample.renderManagerMs);
+		commitMs.push(sample.commitMs);
+		scannedNodes.push(sample.scannedNodes);
+		paintedNodes.push(sample.paintedNodes);
+		if (sample.domFlushMs != null) domFlushMs.push(sample.domFlushMs);
+		if (sample.stdoutFlushMs != null) stdoutFlushMs.push(sample.stdoutFlushMs);
+		if (sample.dirtyRows == null) fullDirtyFrames++;
+		else dirtyRows.push(sample.dirtyRows);
+		reasons[sample.reason] = (reasons[sample.reason] ?? 0) + 1;
+		const planes = sample.activePlanes;
+		if (!planes) activePlanes.all = (activePlanes.all ?? 0) + 1;
+		else for (const plane of planes) activePlanes[plane] = (activePlanes[plane] ?? 0) + 1;
+		coalescedInvalidates += sample.coalescedInvalidates;
+		coalescedFrameTasks += sample.coalescedFrameTasks;
+		droppedUpdates += sample.droppedUpdates;
+		if (sample.queueDepth > maxQueueDepth) maxQueueDepth = sample.queueDepth;
+		rowBucketFallbacks += sample.rowBucketFallbacks?.length ?? 0;
+	}
+	const first = samples[0] ?? null;
+	const latest = samples[samples.length - 1] ?? null;
+	return {
+		frames: samples.length,
+		firstFrameId: first?.frameId ?? null,
+		latestFrameId: latest?.frameId ?? null,
+		windowMs: first && latest ? Math.max(0, latest.startedAt - first.startedAt) : 0,
+		durationMs: metricStats(durationMs),
+		renderManagerMs: metricStats(renderManagerMs),
+		commitMs: metricStats(commitMs),
+		domFlushMs: metricStats(domFlushMs),
+		stdoutFlushMs: metricStats(stdoutFlushMs),
+		dirtyRows: {
+			avg: dirtyRows.length ? dirtyRows.reduce((sum, value) => sum + value, 0) / dirtyRows.length : 0,
+			max: dirtyRows.length ? Math.max(...dirtyRows) : 0,
+			sampledFrames: dirtyRows.length,
+			fullFrames: fullDirtyFrames
+		},
+		scannedNodes: metricStats(scannedNodes),
+		paintedNodes: metricStats(paintedNodes),
+		coalescedInvalidates,
+		coalescedFrameTasks,
+		droppedUpdates,
+		maxQueueDepth,
+		rowBucketFallbacks,
+		reasons,
+		activePlanes
+	};
+}
+function framePerfNow() {
+	const p = globalThis.performance;
+	if (p && typeof p.now === "function") return p.now();
+	return Date.now();
+}
+function mergeFramePerfReason(prev, next) {
+	const a = prev ?? "unknown";
+	const b = next ?? "unknown";
+	return FRAME_PERF_REASON_PRIORITY[b] > FRAME_PERF_REASON_PRIORITY[a] ? b : a;
+}
+
+//#endregion
+export { framePerfNow, mergeFramePerfReason, summarizeFramePerf };

package/dist/{sgr-BmzxEjAO.js → hyperlink-B35-O-cW.js}

@@ -301,4 +301,103 @@ function parseAnsiSgr(input, baseStyle = {}) {
 }
 
 //#endregion
-export { applyAnsiSgrStyle, parseAnsiSgr };
+//#region src/utils/url-safety.ts
+const ENCODED_ASCII_CONTROL_RE = /%(?:0[0-9a-f]|1[0-9a-f]|7f)/i;
+function hasControlCodePoint(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+function hasEncodedControl(value) {
+	let current = String(value ?? "");
+	for (let depth = 0; depth < 3; depth++) {
+		if (ENCODED_ASCII_CONTROL_RE.test(current)) return true;
+		let decoded;
+		try {
+			decoded = decodeURIComponent(current);
+		} catch {
+			return true;
+		}
+		if (hasControlCodePoint(decoded)) return true;
+		if (decoded === current) return false;
+		current = decoded;
+	}
+	return ENCODED_ASCII_CONTROL_RE.test(current) || hasControlCodePoint(current);
+}
+
+//#endregion
+//#region src/core/hyperlink.ts
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+const BLOCKED_SCHEME_RE = /^(?:javascript|data|vbscript):/i;
+const SAFE_RELATIVE_HREF_RE = /^(?:[A-Za-z0-9._~!$&()*+,;=:@/?#-]|%[0-9A-Fa-f]{2})+$/u;
+function normalizeRawHref(value) {
+	if (typeof value !== "string") return null;
+	const raw = value.trim();
+	if (!raw) return null;
+	if (raw !== value) return null;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code >= 127 && code <= 159) return null;
+	}
+	if (/\s/u.test(raw)) return null;
+	if (raw.startsWith("//")) return null;
+	if (BLOCKED_SCHEME_RE.test(raw)) return null;
+	if (hasEncodedControl(raw)) return null;
+	return raw;
+}
+function hrefScheme(raw) {
+	return raw.match(SCHEME_RE)?.[0].toLowerCase() ?? null;
+}
+function parseSafeAbsoluteUrl(raw) {
+	if (raw.includes("\\")) return null;
+	try {
+		return new URL(raw);
+	} catch {
+		return null;
+	}
+}
+function sanitizeAbsoluteHref(raw, options = {}) {
+	const url = parseSafeAbsoluteUrl(raw);
+	if (!url) return null;
+	if (url.protocol === "http:" || url.protocol === "https:") {
+		if (!/^https?:\/\//i.test(raw)) return null;
+		return options.preserveHttpHref ? raw : url.toString();
+	}
+	if (url.protocol === "mailto:") return raw;
+	return null;
+}
+function isSafeNormalizedRelativeHref(raw) {
+	if (raw.includes("\\")) return false;
+	if (raw.startsWith("//")) return false;
+	if (SCHEME_RE.test(raw)) return false;
+	if (hasEncodedControl(raw)) return false;
+	if (!SAFE_RELATIVE_HREF_RE.test(raw)) return false;
+	return raw.startsWith("#") || raw.startsWith("?") || raw.startsWith("/") || raw.startsWith("./") || raw.startsWith("../") || /^[A-Za-z0-9._~-]/u.test(raw);
+}
+function isSafeRelativeHref(value) {
+	const raw = normalizeRawHref(value);
+	return raw != null && isSafeNormalizedRelativeHref(raw);
+}
+function sanitizeTerminalHref(value, options = {}) {
+	const raw = normalizeRawHref(value);
+	if (!raw) return null;
+	const sanitized = sanitizeAbsoluteHref(raw, { preserveHttpHref: true });
+	if (sanitized) return sanitized;
+	if (options.allowFileUrls) {
+		const url = parseSafeAbsoluteUrl(raw);
+		if (url?.protocol === "file:") return url.toString();
+	}
+	return null;
+}
+function sanitizeDomHref(value, options = {}) {
+	const raw = normalizeRawHref(value);
+	if (!raw) return null;
+	const scheme = hrefScheme(raw);
+	if (!scheme) return options.allowRelative !== false && isSafeNormalizedRelativeHref(raw) ? raw : null;
+	return sanitizeAbsoluteHref(raw);
+}
+
+//#endregion
+export { applyAnsiSgrStyle, hasEncodedControl, isSafeRelativeHref, parseAnsiSgr, sanitizeDomHref, sanitizeTerminalHref };