pygpt-net 2.6.55__py3-none-any.whl → 2.6.56__py3-none-any.whl

pygpt_net/data/js/app/math.js

@@ -0,0 +1,167 @@
+// ==========================================================================
+// Math renderer (async, chunked)
+// ==========================================================================
+
+class MathRenderer {
+
+	// Math renderer for LaTeX formulas.
+	constructor(cfg, raf, asyncer) {
+		this.cfg = cfg;
+		this.raf = raf;
+		this.asyncer = asyncer;
+		this.scheduled = false;
+
+		// rAF key used by the central pump (do not change – API compatibility).
+		this.rafKey = {
+			t: 'Math:render'
+		};
+
+		// Pending roots aggregation: if document-level render is requested, it supersedes others.
+		this._pendingRoots = new Set();
+		this._pendingDoc = false;
+	}
+
+	// Async, cooperative KaTeX rendering to avoid long blocking on many formulas.
+	async renderAsync(root) {
+		if (typeof katex === 'undefined') return;
+		const scope = root || document;
+		const scripts = Array.from(scope.querySelectorAll('script[type^="math/tex"]'));
+		const useToString = (typeof katex.renderToString === 'function');
+
+		const batchFn = async (script) => {
+			if (!script || !script.isConnected) return;
+			// Only render math in bot messages
+			if (!script.closest('.msg-box.msg-bot')) return;
+			const t = script.getAttribute('type') || '';
+			const displayMode = t.indexOf('mode=display') > -1;
+			// avoid innerText (it may trigger layout). textContent is sufficient here.
+			const mathContent = script.textContent || '';
+			const parent = script.parentNode;
+			if (!parent) return;
+
+			try {
+				if (useToString) {
+					let html = '';
+					try {
+						html = katex.renderToString(mathContent, {
+							displayMode,
+							throwOnError: false
+						});
+					} catch (_) {
+						const fb = displayMode ? `\\[${mathContent}\\]` : `\\(${mathContent}\\)`;
+						html = (displayMode ? `<div>${Utils.escapeHtml(fb)}</div>` : `<span>${Utils.escapeHtml(fb)}</span>`);
+					}
+					const host = document.createElement(displayMode ? 'div' : 'span');
+					host.innerHTML = html;
+					const el = host.firstElementChild || host;
+					if (parent.classList && parent.classList.contains('math-pending')) parent.replaceWith(el);
+					else parent.replaceChild(el, script);
+				} else {
+					const el = document.createElement(displayMode ? 'div' : 'span');
+					try {
+						katex.render(mathContent, el, {
+							displayMode,
+							throwOnError: false
+						});
+					} catch (_) {
+						el.textContent = (displayMode ? `\\[${mathContent}\\]` : `\\(${mathContent}\\)`);
+					}
+					if (parent.classList && parent.classList.contains('math-pending')) parent.replaceWith(el);
+					else parent.replaceChild(el, script);
+				}
+			} catch (_) {
+				// Keep fallback text intact on any error
+			}
+		};
+
+		// Process formulas cooperatively (rAF yields).
+		await this.asyncer.forEachChunk(scripts, batchFn, 'MathRenderer');
+	}
+
+	// Schedule math rendering for a root. Coalesces multiple calls.
+	schedule(root, _delayIgnored = 0, forceNow = false) {
+		// If KaTeX is not available, honor no-op. API stays intact.
+		if (typeof katex === 'undefined') return;
+
+		// Normalize root (default to whole document).
+		const targetRoot = root || document;
+
+		// Fast existence check to avoid arming rAF when nothing to do, but still
+		// keep aggregation semantics: if a job is already scheduled we can still
+		// merge new roots into the pending set when they actually contain math.
+		let hasMath = true;
+		if (!forceNow) {
+			try {
+				hasMath = !!(targetRoot && targetRoot.querySelector && targetRoot.querySelector('script[type^="math/tex"]'));
+			} catch (_) {
+				hasMath = false;
+			}
+			if (!hasMath) return; // nothing to render for this root; safe early exit
+		}
+
+		// Aggregate roots so nothing is lost while one job is already scheduled.
+		if (targetRoot === document || targetRoot === document.documentElement || targetRoot === document.body) {
+			this._pendingDoc = true; // promote to a full-document sweep
+			this._pendingRoots.clear(); // small optimization (document covers all)
+		} else if (!this._pendingDoc) {
+			this._pendingRoots.add(targetRoot);
+		}
+
+		// If a task is already scheduled, do not arm another – coalescing will take care of it.
+		if (this.scheduled && this.raf && typeof this.raf.isScheduled === 'function' && this.raf.isScheduled(this.rafKey)) return;
+
+		this.scheduled = true;
+		const priority = forceNow ? 0 : 2;
+
+		// Single rAF job drains all pending roots; renderAsync remains public and unchanged.
+		this.raf.schedule(this.rafKey, () => {
+			this.scheduled = false;
+
+			const useDoc = this._pendingDoc;
+			const roots = [];
+
+			if (useDoc) {
+				roots.push(document);
+			} else {
+				this._pendingRoots.forEach((r) => {
+					// Only keep connected elements to avoid useless work.
+					try {
+						if (r && (r.isConnected === undefined || r.isConnected)) roots.push(r);
+					} catch (_) {
+						// Conservative: keep the root; renderAsync guards internally.
+						roots.push(r);
+					}
+				});
+			}
+
+			// Reset aggregation state before running (new calls can aggregate afresh).
+			this._pendingDoc = false;
+			this._pendingRoots.clear();
+
+			// Fire-and-forget async drain; keep renderAsync API intact.
+			(async () => {
+				for (let i = 0; i < roots.length; i++) {
+					try {
+						await this.renderAsync(roots[i]);
+					} catch (_) {
+						/* swallow – resilient */
+					}
+				}
+			})();
+		}, 'Math', priority);
+	}
+
+	// Cleanup pending work and state.
+	cleanup() {
+		try {
+			this.raf.cancelGroup('Math');
+		} catch (_) {}
+		this.scheduled = false;
+
+		// Ensure pending state is fully cleared on cleanup.
+		try {
+			this._pendingRoots.clear();
+		} catch (_) {}
+		this._pendingDoc = false;
+	}
+}

pygpt_net/data/js/app/nodes.js

@@ -0,0 +1,395 @@
+// ==========================================================================
+// Nodes manager
+// ==========================================================================
+
+class NodesManager {
+
+	// Nodes manager for handling message nodes.
+	constructor(dom, renderer, highlighter, math) {
+		this.dom = dom;
+		this.renderer = renderer;
+		this.highlighter = highlighter;
+		this.math = math;
+		// User message collapse manager
+		this._userCollapse = new UserCollapseManager(this.renderer.cfg);
+	}
+
+	// Check if HTML contains only user messages without any markdown or code features.
+	_isUserOnlyContent(html) {
+		try {
+			const tmp = document.createElement('div');
+			tmp.innerHTML = html;
+			const hasBot = !!tmp.querySelector('.msg-box.msg-bot');
+			const hasUser = !!tmp.querySelector('.msg-box.msg-user');
+			const hasMD64 = !!tmp.querySelector('[data-md64]');
+			const hasMDNative = !!tmp.querySelector('[md-block-markdown]');
+			const hasCode = !!tmp.querySelector('pre code');
+			const hasMath = !!tmp.querySelector('script[type^="math/tex"]');
+			return hasUser && !hasBot && !hasMD64 && !hasMDNative && !hasCode && !hasMath;
+		} catch (_) {
+			return false;
+		}
+	}
+
+	// Convert user markdown placeholders into plain text nodes.
+	_materializeUserMdAsPlainText(scopeEl) {
+		try {
+			const nodes = scopeEl.querySelectorAll('.msg-box.msg-user [data-md64], .msg-box.msg-user [md-block-markdown]');
+			nodes.forEach(el => {
+				let txt = '';
+				if (el.hasAttribute('data-md64')) {
+					const b64 = el.getAttribute('data-md64') || '';
+					el.removeAttribute('data-md64');
+					try {
+						txt = this.renderer.b64ToUtf8(b64);
+					} catch (_) {
+						txt = '';
+					}
+				} else {
+					// Native Markdown block in user message: keep as plain text (no markdown-it)
+					try {
+						txt = el.textContent || '';
+					} catch (_) {
+						txt = '';
+					}
+					try {
+						el.removeAttribute('md-block-markdown');
+					} catch (_) {}
+				}
+				const span = document.createElement('span');
+				span.textContent = txt;
+				el.replaceWith(span);
+			});
+		} catch (_) {}
+	}
+
+	// Ensure user copy icon exists inside each user message (.msg) under root.
+	_ensureUserCopyIcons(root) {
+		try {
+			const scope = root || document;
+			const cfg = (this.renderer && this.renderer.cfg) || {};
+			const I = cfg.ICONS || {};
+			const L = cfg.LOCALE || {};
+			const copyIcon = I.CODE_COPY || '';
+			const copyTitle = L.COPY || 'Copy';
+
+			const list = scope.querySelectorAll('.msg-box.msg-user .msg');
+			for (let i = 0; i < list.length; i++) {
+				const msg = list[i];
+				if (!msg || !msg.isConnected) continue;
+
+				// If exists but sits inside .uc-content, move it up to .msg for stable absolute positioning.
+				const existing = msg.querySelector('.msg-copy-btn');
+				if (existing) {
+					try {
+						const p = existing.parentElement;
+						if (p && p.classList && p.classList.contains('uc-content')) {
+							msg.insertAdjacentElement('afterbegin', existing);
+						}
+					} catch (_) {}
+					continue;
+				}
+
+				const a = document.createElement('a');
+				a.href = 'empty:0';
+				a.className = 'msg-copy-btn';
+				a.setAttribute('role', 'button');
+				a.setAttribute('title', copyTitle);
+				a.setAttribute('aria-label', copyTitle);
+				a.setAttribute('data-tip', copyTitle);
+
+				try {
+					const box = msg.closest('.msg-box.msg-user');
+					if (box && box.id && box.id.startsWith('msg-user-')) {
+						const id = box.id.slice('msg-user-'.length);
+						a.setAttribute('data-id', id);
+					}
+				} catch (_) {}
+
+				const img = document.createElement('img');
+				img.className = 'copy-img';
+				img.src = copyIcon;
+				img.alt = copyTitle;
+
+				a.appendChild(img);
+
+				try {
+					msg.insertAdjacentElement('afterbegin', a);
+				} catch (_) {
+					try {
+						msg.appendChild(a);
+					} catch (__) {}
+				}
+			}
+		} catch (_) {}
+	}
+
+	// Append HTML/text into the message input container.
+	// If plain text is provided, wrap it into a minimal msg-user box to keep layout consistent.
+	appendToInput(content) {
+		const el = this.dom.get('_append_input_');
+		if (!el) return;
+
+		let html = String(content || '');
+		const trimmed = html.trim();
+
+		// If already a full msg-user wrapper, append as-is; otherwise wrap the plain text.
+		const isWrapped = (trimmed.startsWith('<div') && /class=["']msg-box msg-user["']/.test(trimmed));
+		if (!isWrapped) {
+			// Treat incoming payload as plain text (escape + convert newlines to <br>).
+			const safe = (typeof Utils !== 'undefined' && Utils.escapeHtml) ?
+				Utils.escapeHtml(html) :
+				String(html).replace(/[&<>"']/g, m => ({
+					'&': '&amp;',
+					'<': '&lt;',
+					'>': '&gt;',
+					'"': '&quot;',
+					"'": '&#039;'
+				} [m]));
+			const body = safe.replace(/\r?\n/g, '<br>');
+			// Minimal, margin-less user message (no empty msg-extra to avoid extra spacing).
+			html = `<div class="msg-box msg-user"><div class="msg"><p style="margin:0">${body}</p></div></div>`;
+		}
+
+		// Synchronous DOM update.
+		el.insertAdjacentHTML('beforeend', html);
+
+		// Apply collapse to any user messages in input area (now or later).
+		try {
+			this._userCollapse.apply(el);
+		} catch (_) {}
+
+		// Ensure copy icons exist (inject or reposition outside uc-content).
+		try {
+			this._ensureUserCopyIcons(el);
+		} catch (_) {}
+	}
+
+	// Append nodes into messages list and perform post-processing (markdown, code, math).
+	appendNode(content, scrollMgr) {
+		// Keep scroll behavior consistent with existing logic
+		scrollMgr.userInteracted = false;
+		scrollMgr.prevScroll = 0;
+		this.dom.clearStreamBefore();
+
+		const el = this.dom.get('_nodes_');
+		if (!el) return;
+		el.classList.remove('empty_list');
+
+		const userOnly = this._isUserOnlyContent(content);
+		if (userOnly) {
+			el.insertAdjacentHTML('beforeend', content);
+			this._materializeUserMdAsPlainText(el);
+			// Collapse before scrolling to ensure final height is used for scroll computations.
+			try {
+				this._userCollapse.apply(el);
+			} catch (_) {}
+			// Ensure copy icons exist for user messages.
+			try {
+				this._ensureUserCopyIcons(el);
+			} catch (_) {}
+
+			scrollMgr.scrollToBottom(false);
+			scrollMgr.scheduleScrollFabUpdate();
+			return;
+		}
+
+		el.insertAdjacentHTML('beforeend', content);
+
+		try {
+			// Defer post-processing (highlight/math/collapse) and perform scroll AFTER collapse.
+			const maybePromise = this.renderer.renderPendingMarkdown(el);
+			const post = () => {
+				// Viewport highlight scheduling
+				try {
+					this.highlighter.scheduleScanVisibleCodes(null);
+				} catch (_) {}
+
+				// In finalize-only mode we must explicitly schedule KaTeX
+				try {
+					if (getMathMode() === 'finalize-only') this.math.schedule(el, 0, true);
+				} catch (_) {}
+
+				// Collapse user messages now that DOM is materialized (ensures correct height).
+				try {
+					this._userCollapse.apply(el);
+				} catch (_) {}
+
+				// Ensure copy icons exist for user messages.
+				try {
+					this._ensureUserCopyIcons(el);
+				} catch (_) {}
+
+				// Only now scroll to bottom and update FAB – uses post-collapse heights.
+				scrollMgr.scrollToBottom(false);
+				scrollMgr.scheduleScrollFabUpdate();
+			};
+
+			if (maybePromise && typeof maybePromise.then === 'function') {
+				maybePromise.then(post);
+			} else {
+				post();
+			}
+		} catch (_) {
+			// In case of error, do a conservative scroll to keep UX responsive.
+			scrollMgr.scrollToBottom(false);
+			scrollMgr.scheduleScrollFabUpdate();
+		}
+	}
+
+	// Replace messages list content entirely and re-run post-processing.
+	replaceNodes(content, scrollMgr) {
+		// Same semantics as appendNode, but using a hard clone reset
+		scrollMgr.userInteracted = false;
+		scrollMgr.prevScroll = 0;
+		this.dom.clearStreamBefore();
+
+		const el = this.dom.hardReplaceByClone('_nodes_');
+		if (!el) return;
+		el.classList.remove('empty_list');
+
+		const userOnly = this._isUserOnlyContent(content);
+		if (userOnly) {
+			el.insertAdjacentHTML('beforeend', content);
+			this._materializeUserMdAsPlainText(el);
+			// Collapse before scrolling to ensure final height is used for scroll computations.
+			try {
+				this._userCollapse.apply(el);
+			} catch (_) {}
+			// Ensure copy icons exist for user messages.
+			try {
+				this._ensureUserCopyIcons(el);
+			} catch (_) {}
+
+			scrollMgr.scrollToBottom(false, true);
+			scrollMgr.scheduleScrollFabUpdate();
+			return;
+		}
+
+		el.insertAdjacentHTML('beforeend', content);
+
+		try {
+			// Defer KaTeX schedule to post-Markdown to avoid races and collapse before scroll.
+			const maybePromise = this.renderer.renderPendingMarkdown(el);
+			const post = () => {
+				try {
+					this.highlighter.scheduleScanVisibleCodes(null);
+				} catch (_) {}
+				try {
+					if (getMathMode() === 'finalize-only') this.math.schedule(el, 0, true);
+				} catch (_) {}
+
+				// Collapse after materialization to compute final heights correctly.
+				try {
+					this._userCollapse.apply(el);
+				} catch (_) {}
+
+				// Ensure copy icons exist for user messages.
+				try {
+					this._ensureUserCopyIcons(el);
+				} catch (_) {}
+
+				// Now scroll and update FAB using the collapsed layout.
+				scrollMgr.scrollToBottom(false, true);
+				scrollMgr.scheduleScrollFabUpdate();
+			};
+
+			if (maybePromise && typeof maybePromise.then === 'function') {
+				maybePromise.then(post);
+			} else {
+				post();
+			}
+		} catch (_) {
+			scrollMgr.scrollToBottom(false, true);
+			scrollMgr.scheduleScrollFabUpdate();
+		}
+	}
+
+	// Append "extra" content into a specific bot message and post-process locally.
+	appendExtra(id, content, scrollMgr) {
+		const el = document.getElementById('msg-bot-' + id);
+		if (!el) return;
+		const extra = el.querySelector('.msg-extra');
+		if (!extra) return;
+
+		extra.insertAdjacentHTML('beforeend', content);
+
+		try {
+			const maybePromise = this.renderer.renderPendingMarkdown(extra);
+
+			const post = () => {
+				const activeCode = (typeof runtime !== 'undefined' && runtime.stream) ? runtime.stream.activeCode : null;
+
+				// Attach observers after Markdown produced the nodes
+				try {
+					this.highlighter.observeNewCode(extra, {
+						deferLastIfStreaming: true,
+						minLinesForLast: this.renderer.cfg.PROFILE_CODE.minLinesForHL,
+						minCharsForLast: this.renderer.cfg.PROFILE_CODE.minCharsForHL
+					}, activeCode);
+					this.highlighter.observeMsgBoxes(extra, (box) => this._onBox(box));
+				} catch (_) {}
+
+				// KaTeX: honor stream mode; in finalize-only force immediate schedule
+				try {
+					const mm = getMathMode();
+					if (mm === 'finalize-only') this.math.schedule(extra, 0, true);
+					else this.math.schedule(extra);
+				} catch (_) {}
+			};
+
+			if (maybePromise && typeof maybePromise.then === 'function') {
+				maybePromise.then(post);
+			} else {
+				post();
+			}
+		} catch (_) {
+			/* swallow */
+		}
+
+		scrollMgr.scheduleScroll(true);
+	}
+
+	// When a new message box appears, hook up code/highlight handlers.
+	_onBox(box) {
+		const activeCode = (typeof runtime !== 'undefined' && runtime.stream) ? runtime.stream.activeCode : null;
+		this.highlighter.observeNewCode(box, {
+			deferLastIfStreaming: true,
+			minLinesForLast: this.renderer.cfg.PROFILE_CODE.minLinesForHL,
+			minCharsForLast: this.renderer.cfg.PROFILE_CODE.minCharsForHL
+		}, activeCode);
+		this.renderer.hooks.codeScrollInit(box);
+	}
+
+	// Remove message by id and keep scroll consistent.
+	removeNode(id, scrollMgr) {
+		scrollMgr.prevScroll = 0;
+		let el = document.getElementById('msg-user-' + id);
+		if (el) el.remove();
+		el = document.getElementById('msg-bot-' + id);
+		if (el) el.remove();
+		this.dom.resetEphemeral();
+		try {
+			this.renderer.renderPendingMarkdown();
+		} catch (_) {}
+		scrollMgr.scheduleScroll(true);
+	}
+
+	// Remove all messages from (and including) a given message id.
+	removeNodesFromId(id, scrollMgr) {
+		scrollMgr.prevScroll = 0;
+		const container = this.dom.get('_nodes_');
+		if (!container) return;
+		const elements = container.querySelectorAll('.msg-box');
+		let remove = false;
+		elements.forEach((element) => {
+			if (element.id && element.id.endsWith('-' + id)) remove = true;
+			if (remove) element.remove();
+		});
+		this.dom.resetEphemeral();
+		try {
+			this.renderer.renderPendingMarkdown(container);
+		} catch (_) {}
+		scrollMgr.scheduleScroll(true);
+	}
+}