zerochat 7.3.0__py3-none-any.whl

zerochat_runtime/assets/js/ui-dialogs.js

@@ -0,0 +1,132 @@
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatDialogs = factory(root.ChatState, root.ChatI18n, root.document);
+})(typeof self !== 'undefined' ? self : this, function (state, i18n, document) {
+  'use strict';
+
+  function create(store, translations, doc) {
+    const dialog = doc.getElementById('notice-dialog');
+    const title = doc.getElementById('notice-title');
+    const message = doc.getElementById('notice-message');
+    const accept = doc.getElementById('notice-accept');
+    const cancel = doc.getElementById('notice-cancel');
+    const input = doc.getElementById('notice-input');
+    const checkboxContainer = doc.getElementById('notice-checkbox-container');
+    const checkbox = doc.getElementById('notice-checkbox');
+    const checkboxText = doc.getElementById('notice-checkbox-text');
+    let activeId = null;
+    let previousFocus = null;
+
+    function render() {
+      const notice = (store.get('ui').notices || [])[0];
+      if (notice?.id === activeId) return;
+      activeId = notice?.id || null;
+      if (!notice) {
+        input.value = '';
+        if (checkbox) checkbox.checked = false;
+        if (checkboxContainer) checkboxContainer.hidden = true;
+        accept.setAttribute('data-i18n', 'notice_accept');
+        accept.textContent = translations.t('notice_accept');
+        cancel.setAttribute('data-i18n', 'notice_cancel');
+        cancel.textContent = translations.t('notice_cancel');
+        if (dialog.open) dialog.close();
+        if (previousFocus?.isConnected) previousFocus.focus();
+        previousFocus = null;
+        return;
+      }
+      title.textContent = notice.title;
+      message.textContent = notice.message;
+      if (notice.acceptText) {
+        accept.removeAttribute('data-i18n');
+        accept.textContent = notice.acceptText;
+      } else {
+        accept.setAttribute('data-i18n', 'notice_accept');
+        accept.textContent = translations.t('notice_accept');
+      }
+      if (notice.cancelText) {
+        cancel.removeAttribute('data-i18n');
+        cancel.textContent = notice.cancelText;
+      } else {
+        cancel.setAttribute('data-i18n', 'notice_cancel');
+        cancel.textContent = translations.t('notice_cancel');
+      }
+      cancel.hidden = notice.mode === 'alert';
+      input.hidden = notice.mode !== 'prompt';
+      input.value = notice.mode === 'prompt' ? notice.value : '';
+      if (checkboxContainer) {
+        checkboxContainer.hidden = !notice.checkbox;
+        if (checkboxText) checkboxText.textContent = notice.checkbox || '';
+        if (checkbox) checkbox.checked = Boolean(notice.checkboxDefault);
+      }
+      dialog.dataset.type = notice.type;
+      if (!dialog.open) {
+        previousFocus = doc.activeElement;
+        dialog.showModal();
+      }
+      (notice.mode === 'prompt' ? input : notice.mode === 'confirm' ? cancel : accept).focus();
+      if (notice.mode === 'prompt') input.select();
+    }
+    function dismiss(accepted = false) {
+      if (activeId !== null) {
+        const isChecked = Boolean(checkbox && checkbox.checked);
+        store.dismissNotice(activeId, accepted, input.value, isChecked);
+      }
+    }
+    input.addEventListener('keydown', event => {
+      if (event.key === 'Enter' && !event.isComposing) {
+        event.preventDefault();
+        event.stopPropagation();
+        dismiss(true);
+      }
+    });
+    accept.addEventListener('click', () => dismiss(true));
+    cancel.addEventListener('click', () => dismiss(false));
+    dialog.addEventListener('cancel', event => { event.preventDefault(); dismiss(); });
+    dialog.addEventListener('close', () => { if (!dialog.open) dismiss(); });
+    store.subscribe(s => JSON.stringify(s.ui.notices || []), render);
+    render();
+
+    function enqueue(message, options, mode, value) {
+      const type = options.type || 'info';
+      const id = store.enqueueNotice({
+        message: String(message ?? ''),
+        title: String(options.title ?? translations.t(mode === 'prompt' ? 'notice_prompt' : mode === 'confirm' ? 'notice_confirm' : 'notice_' + type)),
+        type,
+        mode,
+        value,
+        acceptText: options.acceptText,
+        cancelText: options.cancelText,
+        checkbox: options.checkbox,
+        checkboxDefault: options.checkboxDefault
+      });
+      return new Promise(resolve => {
+        const unsubscribe = store.subscribe(s => (s.ui.notices || []).some(item => item.id === id), present => {
+          if (!present) {
+            unsubscribe();
+            const result = store.get('ui').noticeResult;
+            const accepted = result?.id === id && result.accepted === true;
+            const checkboxChecked = Boolean(result?.id === id && result.checkboxChecked === true);
+            if (options.checkbox !== undefined || options.returnDetails) {
+              resolve({ accepted, applyToAll: checkboxChecked, checkboxChecked, value: result?.value ?? null });
+            } else {
+              resolve(mode === 'prompt' ? (accepted ? result.value : null) : mode === 'confirm' ? accepted : undefined);
+            }
+          }
+        });
+      });
+    }
+    return {
+      alert: (message, options = {}) => enqueue(message, options, 'alert'),
+      confirm: (message, options = {}) => enqueue(message, options, 'confirm'),
+      prompt: (message, defaultValue = '', options = {}) => enqueue(message, options, 'prompt', defaultValue),
+      askDuplicate: (message, options = {}) => enqueue(message, {
+        ...options,
+        type: options.type || 'info',
+        acceptText: options.acceptText || translations.t('rag_btn_replace'),
+        cancelText: options.cancelText || translations.t('rag_btn_ignore'),
+        checkbox: options.checkbox || translations.t('rag_duplicate_apply_all')
+      }, 'confirm')
+    };
+  }
+  return document ? create(state, i18n, document) : { create };
+});

zerochat_runtime/assets/js/ui-generation-status.js

@@ -0,0 +1,119 @@
+/**
+ * General-purpose progress status indicator for the composer.
+ * Displays brief, non-sensitive progress messages announced by any module
+ * (providers, RAG, tools, MCP, agent loop) during an active chat cycle.
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatUIGenerationStatus = factory();
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  let elapsedTimer = null;
+
+  function resolveI18n() {
+    if (typeof window !== 'undefined') return window.ChatI18n;
+    if (typeof require !== 'undefined') { try { return require('./i18n.js'); } catch (_) {} }
+    return null;
+  }
+
+  function t(key, params) {
+    return resolveI18n()?.t?.(key, params) || key;
+  }
+
+  function getViewModel(status = {}, now = Date.now()) {
+    const raw = typeof status === 'string' ? { text: status } : (status || {});
+    const phase = String(raw.phase || (raw.text || raw.message ? 'custom' : 'idle'));
+    const percent = raw.percent != null && raw.percent !== '' && Number.isFinite(Number(raw.percent))
+      ? Math.round(Math.max(0, Math.min(100, Number(raw.percent))))
+      : null;
+    const elapsed = phase === 'thinking' && raw.startedAt != null && raw.startedAt !== '' && Number.isFinite(Number(raw.startedAt))
+      ? Math.max(0, Math.floor((now - Number(raw.startedAt)) / 1000)) : null;
+    const labels = {
+      connecting: t('generation_status_connecting'),
+      preparing: t('generation_status_preparing'),
+      loading: t('generation_status_loading'),
+      compiling: t('generation_status_compiling'),
+      ready: t('generation_status_generating'),
+      thinking: t('generation_status_thinking'),
+      generating: t('generation_status_generating'),
+      rag: t('generation_status_rag')
+    };
+    let text = raw.text || raw.message || labels[phase] || (phase !== 'idle' ? t('generation_status_generating') : '');
+    if (phase === 'idle') text = '';
+    if (text && percent !== null) text = t('generation_status_percent', { text, percent });
+    if (text && elapsed !== null) text = t('generation_status_elapsed', { text, seconds: elapsed });
+    const active = Boolean(text) && phase !== 'idle';
+    return { active, phase, percent, text };
+  }
+
+  function render(element, status) {
+    if (!element) return;
+    const view = getViewModel(status);
+    element.hidden = !view.active;
+    if (!view.active) {
+      if (elapsedTimer) clearInterval(elapsedTimer);
+      elapsedTimer = null;
+      return;
+    }
+    element.dataset.phase = view.phase;
+    const text = element.querySelector?.('.generation-status-text');
+    if (text) text.textContent = view.text;
+    const progress = element.querySelector?.('.generation-status-progress');
+    if (progress) {
+      progress.hidden = view.percent === null;
+      if (view.percent !== null) progress.value = view.percent;
+    }
+    if (elapsedTimer) clearInterval(elapsedTimer);
+    elapsedTimer = null;
+    if (view.phase === 'thinking') {
+      elapsedTimer = setInterval(() => render(element, status), 1000);
+    }
+  }
+
+  function resolveState() {
+    if (typeof window !== 'undefined' && window.ChatState) return window.ChatState;
+    if (typeof globalThis !== 'undefined' && globalThis.ChatState) return globalThis.ChatState;
+    if (typeof require !== 'undefined') { try { return require('./state.js'); } catch (_) {} }
+    return null;
+  }
+
+  function setStatus(element, update = {}) {
+    const State = resolveState();
+    const raw = typeof update === 'string' ? { text: update } : (update || {});
+    const isGenerating = Boolean(State?.get?.('streaming')?.isGenerating);
+    const phase = String(raw.phase || (raw.text || raw.message ? 'custom' : 'idle'));
+    // Si no se está procesando un ciclo de chat, el indicador permanece invisible y no se reactiva.
+    if (!isGenerating && phase !== 'idle') return;
+
+    let next;
+    if (State?.setGenerationStatus) {
+      next = State.setGenerationStatus(raw);
+    } else if (State?.get && State?.set) {
+      const ui = State.get('ui') || {};
+      const current = ui.generationStatus || { phase: 'idle', percent: null, startedAt: null };
+      const phaseChanged = phase !== current.phase;
+      next = phaseChanged
+        ? { text: '', message: '', detail: '', percent: null, ...raw, phase, startedAt: Date.now() }
+        : { ...current, ...raw, phase, startedAt: current.startedAt || Date.now() };
+      State.set('ui', { ...ui, generationStatus: next });
+    } else {
+      next = { ...raw, phase, startedAt: Date.now() };
+    }
+    render(element, next);
+    return next;
+  }
+
+  function clearStatus(element) {
+    const State = resolveState();
+    if (State?.clearGenerationStatus) {
+      State.clearGenerationStatus();
+    } else if (State?.get && State?.set) {
+      const ui = State.get('ui') || {};
+      State.set('ui', { ...ui, generationStatus: { phase: 'idle', percent: null, text: '', message: '', detail: '', startedAt: null } });
+    }
+    render(element, { phase: 'idle' });
+  }
+
+  return { getViewModel, render, setStatus, clearStatus };
+}));