Spaces:
Running
Running
Download js/ide.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 36.8 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/ide.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/ide.js
-
curl -L -o ide.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/ide.js
36.8 kB
| // IDE: Monaco (el editor de VS Code) + árbol de archivos + pestañas. | |
| import * as code from './tools/code.js'; | |
| import * as db from './db.js'; | |
| import { fileIcon, folderIcon } from './icons.js'; | |
| import { renderMarkdown } from './md.js'; | |
| import { t } from './i18n.js'; | |
| let editor = null; | |
| let monacoRef = null; | |
| let ext = null; // extensiones de VS Code (js/ext/host.js), ver loadExt() | |
| const tabs = []; // { path, model, dirty, preview } | |
| let active = null; | |
| let onDirtyChange = () => {}; | |
| const LANG = { | |
| js: 'javascript', mjs: 'javascript', ts: 'typescript', tsx: 'typescript', | |
| jsx: 'javascript', json: 'json', html: 'html', css: 'css', md: 'markdown', | |
| py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', h: 'c', | |
| cpp: 'cpp', sh: 'shell', yml: 'yaml', yaml: 'yaml', toml: 'ini', | |
| svg: 'xml', xml: 'xml', sql: 'sql', txt: 'plaintext', | |
| }; | |
| // las extensiones instaladas mandan (p. ej. .toml → toml en vez de ini) | |
| const porNombre = p => ext?.languageForPath(p) || LANG[p.split('.').pop().toLowerCase()] || null; | |
| const langOf = p => porNombre(p) || 'plaintext'; | |
| // …y, como en VS Code, la primera línea (firstLine de una extensión) solo | |
| // cuenta si nadie reclama el fichero por su nombre. Va en un Worker con tiempo | |
| // tope: una expresión de un paquete puede no terminar nunca. | |
| const langDe = async (p, primeraLinea) => porNombre(p) || (ext && primeraLinea ? await ext.languageForFirstLine(primeraLinea) : null) || 'plaintext'; | |
| const $ = id => document.getElementById(id); | |
| export async function initEditor() { | |
| await new Promise(res => { | |
| const s = document.createElement('script'); | |
| s.src = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js'; | |
| s.onload = res; | |
| document.head.appendChild(s); | |
| }); | |
| window.require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs' } }); | |
| await new Promise(res => window.require(['vs/editor/editor.main'], res)); | |
| monacoRef = window.monaco; | |
| ext = await loadExt(false); | |
| editor = monacoRef.editor.create($('editor'), { | |
| theme: ext ? ext.themeId() : 'vs-dark', | |
| automaticLayout: true, | |
| fontSize: 13, | |
| minimap: { enabled: false }, | |
| padding: { top: 8 }, | |
| }); | |
| // Al arrancar no hay ningún fichero abierto, y Monaco enseña su documento | |
| // vacío con un «1» suelto. El aviso de «sin ficheros» solo se ponía al CERRAR | |
| // la última pestaña, nunca al empezar. Abrir un fichero lo quita (openFile). | |
| if (!tabs.length) setEmptyState(true); | |
| editor.addCommand(monacoRef.KeyMod.CtrlCmd | monacoRef.KeyCode.KeyS, saveActive); | |
| editor.onDidChangeModelContent(() => { | |
| const tab = tabs.find(t => t.path === active); | |
| if (tab && !tab.dirty) { tab.dirty = true; renderTabs(); } | |
| }); | |
| // los cambios del agente se reflejan al instante en el editor | |
| code.setOnFileWritten((path, content) => { | |
| const tab = tabs.find(t => t.path === path); | |
| if (tab && tab.model.getValue() !== content) { | |
| tab.model.setValue(content); | |
| tab.dirty = false; | |
| renderTabs(); | |
| if (path === active) applyView(); | |
| } | |
| refreshTree(); | |
| }); | |
| } | |
| export function gotoLine(n) { | |
| if (!editor || !n) return; | |
| editor.revealLineInCenter(n); | |
| editor.setPosition({ lineNumber: n, column: 1 }); | |
| editor.focus(); | |
| } | |
| export function triggerEditor(actionId) { | |
| // El foco va ANTES de lanzar la acción, no después. Muchas acciones de Monaco | |
| // abren un widget que toma el foco (quickOutline, por ejemplo), así que un | |
| // `focus()` posterior se lo quitaba y lo cerraba al instante: «Go to symbol» | |
| // no hacía nada visible. Y además varias acciones necesitan que el editor | |
| // tenga el foco para ejecutarse, cosa que no pasa si vienes de pulsar un | |
| // item de menú. | |
| editor?.focus(); | |
| editor?.getAction(actionId)?.run(); | |
| } | |
| export function hasEditor() { return !!editor; } | |
| // Llevar el foco al editor (p. ej. tras «Abrir en el editor» desde la Mente). | |
| export function focusEditor() { try { editor?.focus(); } catch { /* sin editor */ } } | |
| // La ruta del fichero activo (o null): el menú la usa para no lanzar acciones | |
| // del editor que no hacen nada sin un fichero abierto. | |
| export function activeFile() { return active; } | |
| // Las pestañas abiertas y su lenguaje, y el lenguaje que tendría una ruta: el | |
| // panel de extensiones los usa para decir qué ficheros ya se ven distintos. | |
| export function openTabs() { | |
| return tabs.filter(t => !t.model.isDisposed()).map(t => ({ path: t.path, language: t.model.getLanguageId(), active: t.path === active })); | |
| } | |
| export const languageOfPath = p => langOf(p); | |
| // El nivel 2 (ext2/docs.js) necesita los MODELOS de Monaco, no solo su lenguaje: | |
| // pares [ruta, modelo]. Va aparte porque el panel usa la forma de arriba. | |
| export const openTabModels = () => tabs.filter(t => !t.model.isDisposed()).map(t => [t.path, t.model]); | |
| export async function openFile(path) { | |
| let tab = tabs.find(t => t.path === path); | |
| if (!tab) { | |
| let content; | |
| try { content = await code.read({ path }); } | |
| catch (e) { | |
| // la ruta exacta no existe (típico: un enlace del chat solo mencionaba | |
| // el NOMBRE, «config.py», y el fichero real vive en una subcarpeta) → | |
| // si hay una única coincidencia por nombre en el proyecto, ábrela ella | |
| // en vez de rendirte; con varias o ninguna, el error de siempre. | |
| const base = path.split('/').pop(); | |
| const hits = await code.findByName?.(base, 2).catch(() => []) || []; | |
| if (hits.length === 1 && hits[0] !== path) return openFile(hits[0]); | |
| return alertBar(t('openFailed', { path, e: e.message })); | |
| } | |
| const lang = await langDe(path, content.slice(0, 500).split('\n')[0]); | |
| await ext?.prepareLanguage(lang); // la gramática, antes de que exista el modelo | |
| tab = tabs.find(t => t.path === path); // otra llamada pudo abrirla mientras tanto | |
| if (!tab) { | |
| tab = { path, model: monacoRef.editor.createModel(content, lang), dirty: false, preview: false }; | |
| tabs.push(tab); | |
| } | |
| } | |
| active = path; | |
| code.setCurrentFile(path); | |
| editor.setModel(tab.model); | |
| setEmptyState(false); | |
| renderTabs(); | |
| await applyView(); | |
| } | |
| // modo «Vista previa» de un tab .md/.html: en vez del código fuente en | |
| // Monaco, muestra el markdown renderizado (mismo motor que el chat y la | |
| // Mente) o el HTML en un iframe real. | |
| const PREVIEWABLE = new Set(['markdown', 'html']); | |
| // resuelve una ruta relativa (href/src) contra la carpeta del propio fichero | |
| function resolveRelative(ownPath, rel) { | |
| if (/^([a-z][\w+.-]*:)?\/\//i.test(rel) || rel.startsWith('data:') || rel.startsWith('#')) return null; // externa/absoluta: no tocar | |
| const baseDir = ownPath.includes('/') ? ownPath.slice(0, ownPath.lastIndexOf('/')) : ''; | |
| const segs = (baseDir ? baseDir.split('/') : []).concat(rel.split('/')); | |
| const out = []; | |
| for (const s of segs) { if (!s || s === '.') continue; if (s === '..') out.pop(); else out.push(s); } | |
| return out.join('/'); | |
| } | |
| // un iframe con srcdoc no tiene base URL propia: <link href="style.css"> o | |
| // <script src="app.js"> del proyecto real NUNCA se resuelven (por eso salía | |
| // sin CSS) — se leen del proyecto de verdad y se incrustan antes de mostrarlo. | |
| // El iframe de Vista previa va con sandbox="allow-scripts" A PROPÓSITO, SIN | |
| // allow-same-origin (aislado de tu proyecto real — ver applyView). Pero eso | |
| // hace que referenciar `localStorage`/`sessionStorage` LANCE una excepción | |
| // síncrona — y como suele ser la primera línea de un script (guardar datos | |
| // es de lo más común), el resto del fichero entero se queda sin ejecutar, | |
| // sin aviso: los botones no hacen nada y parece que la app está rota. Se | |
| // incrusta un shim en memoria (nunca toca almacenamiento real, se pierde al | |
| // cerrar la vista previa) SOLO si de verdad hace falta — si el sandbox | |
| // permitiera acceso real, no se toca nada. | |
| const STORAGE_SHIM = `<script>(()=>{try{window.localStorage;return}catch(e){}` + | |
| `const m=()=>{const d=new Map();return{getItem:k=>d.has(''+k)?d.get(''+k):null,` + | |
| `setItem:(k,v)=>{d.set(''+k,''+v)},removeItem:k=>{d.delete(''+k)},clear:()=>{d.clear()},` + | |
| `key:i=>[...d.keys()][i]??null,get length(){return d.size}}};` + | |
| `for(const p of ['localStorage','sessionStorage'])` + | |
| `try{Object.defineProperty(window,p,{value:m(),configurable:true})}catch(e){}})()<\/script>`; | |
| async function inlineLocalAssets(html, ownPath) { | |
| const doc = new DOMParser().parseFromString(html, 'text/html'); | |
| (doc.head || doc.documentElement).insertAdjacentHTML('afterbegin', STORAGE_SHIM); | |
| for (const link of doc.querySelectorAll('link[rel~="stylesheet"][href]')) { | |
| const path = resolveRelative(ownPath, link.getAttribute('href')); | |
| if (!path) continue; | |
| try { | |
| const style = doc.createElement('style'); | |
| style.textContent = await code.read({ path }); | |
| link.replaceWith(style); | |
| } catch { /* no se pudo leer: se deja el link (el navegador lo ignorará sin más) */ } | |
| } | |
| for (const script of doc.querySelectorAll('script[src]')) { | |
| const path = resolveRelative(ownPath, script.getAttribute('src')); | |
| if (!path) continue; | |
| try { | |
| const inline = doc.createElement('script'); | |
| if (script.type) inline.type = script.type; | |
| inline.textContent = await code.read({ path }); | |
| script.replaceWith(inline); | |
| } catch { /* deja el script tal cual */ } | |
| } | |
| return '<!doctype html>\n' + doc.documentElement.outerHTML; | |
| } | |
| // Guardián opcional de la vista previa HTML (lo pone el nivel 2 de extensiones); | |
| // si falla o dice que no, se vuelve al código. | |
| let beforePreview = null; | |
| export function setBeforePreview(fn) { beforePreview = typeof fn === 'function' ? fn : null; } | |
| async function previewAllowed(path) { | |
| if (!beforePreview) return true; | |
| try { return (await beforePreview(path)) === true; } catch { return false; } | |
| } | |
| async function applyView() { | |
| const tab = tabs.find(t => t.path === active); | |
| const lang = tab ? langOf(tab.path) : null; | |
| if (tab && tab.preview && lang === 'html' && !(await previewAllowed(tab.path))) { | |
| tab.preview = false; | |
| renderTabs(); | |
| return applyView(); | |
| } | |
| const showPreview = !!(tab && tab.preview && PREVIEWABLE.has(lang)); | |
| $('editor').style.display = showPreview ? 'none' : ''; | |
| let pane = document.getElementById('md-preview-pane'); | |
| if (showPreview) { | |
| if (!pane) { | |
| pane = document.createElement('div'); | |
| pane.id = 'md-preview-pane'; | |
| $('editor').parentElement.appendChild(pane); | |
| } | |
| pane.classList.toggle('html-preview', lang === 'html'); | |
| if (lang === 'html') { | |
| pane.replaceChildren(); | |
| const frame = document.createElement('iframe'); | |
| frame.sandbox = 'allow-scripts'; // sin allow-same-origin: aislado de tu proyecto real | |
| frame.srcdoc = await inlineLocalAssets(tab.model.getValue(), tab.path); | |
| pane.appendChild(frame); | |
| } else { | |
| pane.innerHTML = renderMarkdown(tab.model.getValue()); | |
| } | |
| pane.style.display = ''; | |
| } else if (pane) { | |
| pane.style.display = 'none'; | |
| } | |
| } | |
| async function togglePreview(path) { | |
| // el fichero puede no tener pestaña abierta todavía (p.ej. desde el menú | |
| // del EXPLORADOR, no el de una pestaña ya abierta) — se abre primero. | |
| if (active !== path || !tabs.find(t => t.path === path)) await openFile(path); | |
| const tab = tabs.find(t => t.path === path); | |
| if (!tab) return; // openFile no pudo (fichero borrado, etc.) | |
| tab.preview = !tab.preview; | |
| renderTabs(); | |
| await applyView(); | |
| } | |
| // Guardar lo que TÚ has escrito va directo al fichero, no por code.write: esa | |
| // es la vía del agente, con su aprobación («Elffuss quiere escribir…», que | |
| // salía al guardar tu propio fichero con Auto apagado) y sus guardas contra | |
| // reescrituras que recortan medio fichero, que bloqueaban un guardado tuyo | |
| // legítimo sin decir nada. | |
| async function writeOwn(path, content) { | |
| const parts = path.split('/').filter(Boolean); | |
| const name = parts.pop(); | |
| let dir = code.handle(); | |
| for (const s of parts) dir = await dir.getDirectoryHandle(s, { create: true }); | |
| const w = await (await dir.getFileHandle(name, { create: true })).createWritable(); | |
| await w.write(content); | |
| await w.close(); | |
| code.invalidateFileList?.(); | |
| } | |
| async function saveTab(tab) { | |
| const recreado = !!tab.deleted; | |
| try { | |
| await writeOwn(tab.path, tab.model.getValue()); | |
| } catch (e) { | |
| alertBar(t('saveFailed', { path: tab.path, e: e?.message || e })); | |
| return false; | |
| } | |
| tab.dirty = false; | |
| tab.deleted = false; | |
| renderTabs(); | |
| // Guardar una pestaña cuyo fichero se había borrado lo vuelve a crear, y el | |
| // explorador tiene que enseñarlo: writeOwn no pasa por code.write, que era | |
| // quien avisaba al árbol (onFileWritten → refreshTree). | |
| if (recreado) await refreshTree(); | |
| alertBar(t('saved', { path: tab.path })); | |
| return true; | |
| } | |
| // Exportada: la usan el menú File › Guardar y la paleta. Antes ellos lanzaban | |
| // la acción 'workbench.action.files.save', que no existe en el Monaco suelto, | |
| // y no pasaba nada. | |
| export async function saveActive() { | |
| const tab = tabs.find(t => t.path === active); | |
| if (!tab) { alertBar(t('noFileOpen')); return false; } | |
| return saveTab(tab); | |
| } | |
| // Cerrar una pestaña con cambios sin guardar PREGUNTA: Guardar, No guardar o | |
| // Cancelar. Antes se cerraba y los cambios se perdían sin aviso. | |
| function askDirty(tab) { | |
| return new Promise(resolve => { | |
| const dlg = document.createElement('dialog'); | |
| dlg.id = 'dirty-dialog'; | |
| dlg.setAttribute('aria-labelledby', 'dirty-title'); | |
| const h = document.createElement('p'); h.id = 'dirty-title'; h.className = 'dd-title'; | |
| h.textContent = t('dirtyTitle', { name: baseOf(tab.path) }); | |
| const sub = document.createElement('p'); sub.className = 'dd-sub'; sub.textContent = t('dirtyBody'); | |
| const row = document.createElement('div'); row.className = 'dd-row'; | |
| let answer = 'cancel'; | |
| const mk = (label, val, cls) => { | |
| const b = document.createElement('button'); b.type = 'button'; b.textContent = label; b.dataset.val = val; | |
| if (cls) b.className = cls; | |
| b.onclick = () => { answer = val; dlg.close(); }; | |
| row.appendChild(b); return b; | |
| }; | |
| const save = mk(t('dirtySave'), 'save', 'dd-primary'); | |
| mk(t('dirtyDiscard'), 'discard'); | |
| mk(t('dirtyCancel'), 'cancel'); | |
| dlg.append(h, sub, row); | |
| dlg.addEventListener('close', () => { dlg.remove(); resolve(answer); }, { once: true }); | |
| document.body.appendChild(dlg); | |
| dlg.showModal(); | |
| save.focus(); | |
| }); | |
| } | |
| // Devuelve false si el usuario canceló (la pestaña sigue abierta). | |
| async function closeTab(path) { | |
| const i = tabs.findIndex(t => t.path === path); | |
| if (i < 0) return true; | |
| if (tabs[i].dirty) { | |
| const r = await askDirty(tabs[i]); | |
| if (r === 'cancel') return false; | |
| if (r === 'save' && !(await saveTab(tabs[i]))) return false; | |
| } | |
| const j = tabs.findIndex(t => t.path === path); // el diálogo es asíncrono | |
| if (j < 0) return true; | |
| closeTabNow(j); | |
| renderTabs(); | |
| await applyView(); | |
| return true; | |
| } | |
| // Cerrar desde la barra de pestañas (Supr, Cmd/Ctrl+W, la ✕, o «No guardar» en | |
| // el diálogo): el foco va a la pestaña que queda activa, o al aviso de «sin | |
| // ficheros abiertos» si no queda ninguna. Antes caía a <body> (las pestañas de | |
| // conversación ya lo hacían bien; las del editor no). | |
| async function closeTabYEnfoca(path) { | |
| if (!(await closeTab(path))) return false; // cancelado: el diálogo devuelve el foco a la pestaña | |
| const activa = $('tabs-bar')?.querySelector('.tab.active'); | |
| if (activa) activa.focus(); | |
| else { | |
| const vacio = document.getElementById('editor-empty'); | |
| if (vacio) { vacio.tabIndex = -1; vacio.focus(); } else editor?.focus(); | |
| } | |
| return true; | |
| } | |
| // Varias seguidas («Cerrar otras/todas»): se para en la primera que cancelas. | |
| async function closeTabs(paths) { | |
| for (const p of paths) if (!(await closeTab(p))) return false; | |
| return true; | |
| } | |
| function closeTabNow(i) { | |
| const path = tabs[i].path; | |
| tabs[i].model.dispose(); | |
| tabs.splice(i, 1); | |
| if (active === path) { | |
| active = tabs[i - 1]?.path || tabs[0]?.path || null; | |
| code.setCurrentFile(active); | |
| if (active) { editor.setModel(tabs.find(t => t.path === active).model); setEmptyState(false); } | |
| else { editor.setModel(monacoRef.editor.createModel('', 'plaintext')); setEmptyState(true); } | |
| } | |
| } | |
| // Estado vacío: cuando no hay ningún fichero abierto, en vez de dejar el Monaco | |
| // en blanco con un «1», mostramos un placeholder limpio. | |
| export function setEmptyState(on) { | |
| let el = document.getElementById('editor-empty'); | |
| if (!el) { | |
| el = document.createElement('div'); | |
| el.id = 'editor-empty'; | |
| el.innerHTML = '<img src="img/elffuss-code.svg" alt=""><p></p>'; | |
| el.querySelector('p').textContent = t('editorEmpty'); | |
| $('editor').parentElement.appendChild(el); | |
| } | |
| el.style.display = on ? 'flex' : 'none'; | |
| } | |
| function renderTabs() { | |
| const bar = $('tabs-bar'); | |
| bar.replaceChildren(); | |
| bar.setAttribute('role', 'tablist'); | |
| bar.setAttribute('aria-label', t('editorTabs')); | |
| for (const tb of tabs) { | |
| const el = document.createElement('div'); | |
| const on = tb.path === active; | |
| el.className = 'tab' + (on ? ' active' : '') + (tb.preview ? ' tab-preview' : ''); | |
| el.dataset.path = tb.path; | |
| // Pestañas de verdad para el teclado y los lectores de pantalla: antes eran | |
| // <div> sin foco. La activa entra con Tab; ←/→ se mueven entre ellas. | |
| el.setAttribute('role', 'tab'); | |
| el.setAttribute('aria-selected', on ? 'true' : 'false'); | |
| // Nombre propio: sin él, el de la pestaña era el fichero MÁS el botón × que | |
| // lleva dentro («app.js Cerrar app.js»). | |
| el.setAttribute('aria-label', baseOf(tb.path) + (tb.dirty ? ' ' + t('tabUnsaved') : '') + (tb.deleted ? ' — ' + t('fileDeletedDirty') : '')); | |
| el.tabIndex = on ? 0 : -1; | |
| const ico = document.createElement('span'); | |
| ico.className = 'tab-ico'; | |
| ico.innerHTML = fileIcon(tb.path.split('/').pop()); | |
| const name = document.createElement('span'); | |
| name.className = 'tab-name'; | |
| name.textContent = tb.path.split('/').pop(); | |
| name.title = tb.deleted ? tb.path + ' · ' + t('fileDeletedDirty') : tb.path; | |
| if (tb.deleted) name.classList.add('deleted'); | |
| // como VS Code: punto ● si hay cambios sin guardar; × al pasar el ratón. | |
| // Un <button> con nombre accesible (antes un <b> que no recibía el foco). | |
| const x = document.createElement('button'); | |
| x.type = 'button'; | |
| x.className = 'tab-x' + (tb.dirty ? ' dirty' : ''); | |
| x.textContent = tb.dirty ? '●' : '×'; | |
| x.tabIndex = -1; | |
| x.setAttribute('aria-label', t(tb.dirty ? 'closeFileDirty' : 'closeFile', { name: baseOf(tb.path) })); | |
| x.title = x.getAttribute('aria-label'); | |
| x.onclick = e => { e.stopPropagation(); closeTabYEnfoca(tb.path); }; | |
| el.append(ico, name, x); | |
| el.onclick = () => openFile(tb.path); | |
| el.oncontextmenu = e => { e.preventDefault(); openTabMenu(e.clientX, e.clientY, tb.path); }; | |
| el.onkeydown = e => { | |
| const i = tabs.indexOf(tb); | |
| if (e.key === 'ArrowRight' || e.key === 'ArrowLeft') { | |
| e.preventDefault(); | |
| const next = tabs[(i + (e.key === 'ArrowRight' ? 1 : tabs.length - 1)) % tabs.length]; | |
| if (next) openFile(next.path).then(() => bar.querySelector('.tab.active')?.focus()); | |
| } else if (e.key === 'Delete' || ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'w')) { | |
| e.preventDefault(); closeTabYEnfoca(tb.path); | |
| } else if (e.key === 'ContextMenu' || (e.shiftKey && e.key === 'F10')) { | |
| e.preventDefault(); const r = el.getBoundingClientRect(); openTabMenu(r.left, r.bottom, tb.path); | |
| } | |
| }; | |
| bar.appendChild(el); | |
| } | |
| markActive(); | |
| } | |
| // ---------- menús contextuales (pestañas y árbol): teclado y Escape ---------- | |
| // Escape los cierra y el foco vuelve a donde estaba; ↑/↓ recorren las opciones. | |
| function wireMenu(menu, returnFocus) { | |
| menu.setAttribute('role', 'menu'); | |
| const items = () => [...menu.querySelectorAll('[role="menuitem"]')]; | |
| const close = () => { menu.remove(); document.removeEventListener('mousedown', outside); returnFocus?.focus?.(); }; | |
| const outside = ev => { if (!menu.contains(ev.target)) close(); }; | |
| menu.addEventListener('keydown', e => { | |
| const list = items(), i = list.indexOf(document.activeElement); | |
| if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); } | |
| else if (e.key === 'ArrowDown') { e.preventDefault(); list[(i + 1) % list.length]?.focus(); } | |
| else if (e.key === 'ArrowUp') { e.preventDefault(); list[(i - 1 + list.length) % list.length]?.focus(); } | |
| }); | |
| setTimeout(() => document.addEventListener('mousedown', outside), 0); | |
| // dentro de la ventana aunque se abra pegado al borde | |
| const r = menu.getBoundingClientRect(); | |
| if (r.right > innerWidth) menu.style.left = Math.max(4, innerWidth - r.width - 4) + 'px'; | |
| if (r.bottom > innerHeight) menu.style.top = Math.max(4, innerHeight - r.height - 4) + 'px'; | |
| items()[0]?.focus(); | |
| return close; | |
| } | |
| function menuButton(label, fn, cls) { | |
| const b = document.createElement('button'); | |
| b.type = 'button'; | |
| b.className = 'tm-item' + (cls ? ' ' + cls : ''); | |
| b.setAttribute('role', 'menuitem'); | |
| b.textContent = label; | |
| b.dataset.run = '1'; | |
| b._run = fn; | |
| return b; | |
| } | |
| // ---------- menú contextual de las pestañas (botón derecho, estilo VS Code) ---------- | |
| function openTabMenu(x, y, path) { | |
| document.getElementById('tab-menu')?.remove(); | |
| const volver = document.activeElement; | |
| const menu = document.createElement('div'); | |
| menu.id = 'tab-menu'; | |
| menu.style.cssText = `position:fixed;left:${x}px;top:${y}px;z-index:200`; | |
| const i = tabs.findIndex(tb => tb.path === path); | |
| const tab = tabs[i]; | |
| const items = []; | |
| items.push([t('tmClose'), () => closeTab(path)]); | |
| items.push([t('tmCloseOthers'), () => closeTabs(tabs.filter(tb => tb.path !== path).map(tb => tb.path))]); | |
| const toTheRight = tabs.slice(i + 1).map(tb => tb.path); | |
| if (toTheRight.length) items.push([t('tmCloseRight'), () => closeTabs(toTheRight)]); | |
| items.push([t('tmCloseAll'), () => closeTabs(tabs.map(tb => tb.path))]); | |
| items.push(['sep']); | |
| items.push([t('tmCopyPath'), () => copyPath(path)]); | |
| if (PREVIEWABLE.has(langOf(path))) { | |
| items.push([tab?.preview ? t('tmViewSource') : t('tmPreview'), () => togglePreview(path)]); | |
| } | |
| let close = () => menu.remove(); | |
| for (const item of items) { | |
| if (item[0] === 'sep') { menu.appendChild(Object.assign(document.createElement('div'), { className: 'tm-sep', role: 'separator' })); continue; } | |
| const [label, fn] = item; | |
| const b = menuButton(label, fn); | |
| b.onclick = () => { close(); fn(); }; | |
| menu.appendChild(b); | |
| } | |
| document.body.appendChild(menu); | |
| close = wireMenu(menu, volver); | |
| } | |
| // Copiar ruta: antes copiaba sin decir nada. | |
| function copyPath(path) { | |
| const done = () => alertBar(t('pathCopied', { path })); | |
| if (navigator.clipboard?.writeText) navigator.clipboard.writeText(path).then(done, () => alertBar(t('pathCopyFailed'))); | |
| else alertBar(t('pathCopyFailed')); | |
| } | |
| let alertTimer; | |
| function alertBar(msg) { | |
| const el = $('statusbar'); | |
| el.textContent = msg; | |
| clearTimeout(alertTimer); | |
| alertTimer = setTimeout(() => { el.textContent = ''; }, 4000); | |
| } | |
| // ---------- árbol lateral ---------- | |
| const IGNORE = new Set(['node_modules', '.git', 'dist', 'build', 'target', '__pycache__', '.next', 'venv', '.venv', '.DS_Store']); | |
| // Carpetas abiertas, por ruta. refreshTree() reconstruye el árbol entero (cada | |
| // escritura del agente, cada orden del terminal que toca ficheros, crear, | |
| // renombrar o borrar) y antes lo dejaba TODO plegado: perdías el sitio tras | |
| // cada edición. Ahora se vuelven a abrir las que lo estaban. | |
| const openDirs = new Set(); | |
| export async function refreshTree(handle = null) { | |
| const rootHandle = handle || window.__elffussProject; | |
| if (!rootHandle) return; | |
| if (handle) openDirs.clear(); // otro proyecto: empieza plegado | |
| window.__elffussProject = rootHandle; | |
| const cont = $('tree'); | |
| const scroll = cont.scrollTop; | |
| const conFoco = cont.contains(document.activeElement) ? document.activeElement.dataset?.path : null; | |
| const ul = await renderDir(rootHandle, ''); | |
| ul.setAttribute('role', 'tree'); | |
| ul.setAttribute('aria-label', t('explorer')); | |
| cont.replaceChildren(ul); | |
| cont.scrollTop = scroll; | |
| markActive(); | |
| if (conFoco != null) { | |
| const f = cont.querySelector(`[data-path="${CSS.escape(conFoco)}"]`); | |
| if (f) { setRoving(f); f.focus(); } | |
| } | |
| setupTreeMenu(); | |
| } | |
| // El fichero abierto se marca en el árbol (antes no había forma de saber cuál | |
| // era), y es la fila por la que entra el foco con Tab. | |
| function markActive() { | |
| const cont = $('tree'); | |
| if (!cont) return; | |
| let fila = null; | |
| for (const f of cont.querySelectorAll('.file')) { | |
| const on = f.dataset.path === active; | |
| f.classList.toggle('active', on); | |
| f.setAttribute('aria-selected', on ? 'true' : 'false'); | |
| if (on) fila = f; | |
| } | |
| if (!cont.querySelector('[tabindex="0"]') || fila) setRoving(fila || cont.querySelector('summary, .file')); | |
| } | |
| function setRoving(row) { | |
| if (!row) return; | |
| for (const r of $('tree').querySelectorAll('[tabindex="0"]')) if (r !== row) r.tabIndex = -1; | |
| row.tabIndex = 0; | |
| } | |
| const visibleRows = () => [...$('tree').querySelectorAll('summary, .file')].filter(r => r.offsetParent !== null); | |
| // ---------- menú contextual del árbol (botón derecho, estilo VS Code) ---------- | |
| let treeMenuWired = false; | |
| function setupTreeMenu() { | |
| if (treeMenuWired) return; | |
| treeMenuWired = true; | |
| const tree = $('tree'); | |
| tree.addEventListener('contextmenu', e => { | |
| e.preventDefault(); | |
| const node = e.target.closest('[data-path]'); | |
| const path = node ? node.dataset.path : ''; | |
| const kind = node ? node.dataset.kind : 'directory'; // vacío = raíz | |
| openTreeMenu(e.clientX, e.clientY, path, kind); | |
| }); | |
| // Teclado, como un árbol de verdad: ↑/↓ entre filas visibles, → abre una | |
| // carpeta, ← la cierra (o sube a la carpeta madre), Enter abre el fichero, | |
| // Shift+F10 o la tecla de menú abren el menú contextual. Antes las filas de | |
| // fichero eran <span> sin foco y el árbol solo se usaba con el ratón. | |
| tree.addEventListener('keydown', e => { | |
| const row = e.target.closest?.('summary, .file'); | |
| if (!row) return; | |
| const rows = visibleRows(), i = rows.indexOf(row); | |
| const go = r => { if (r) { e.preventDefault(); setRoving(r); r.focus(); } }; | |
| const det = row.tagName === 'SUMMARY' ? row.parentElement : null; | |
| if (e.key === 'ArrowDown') go(rows[i + 1]); | |
| else if (e.key === 'ArrowUp') go(rows[i - 1]); | |
| else if (e.key === 'Home') go(rows[0]); | |
| else if (e.key === 'End') go(rows[rows.length - 1]); | |
| else if (e.key === 'ArrowRight' && det) { e.preventDefault(); if (!det.open) det.open = true; else go(rows[i + 1]); } | |
| else if (e.key === 'ArrowLeft') { | |
| if (det && det.open) { e.preventDefault(); det.open = false; } | |
| else go(row.closest('li')?.parentElement?.closest('details')?.querySelector(':scope > summary')); | |
| } | |
| else if (e.key === 'Enter' && !det) { e.preventDefault(); openFile(row.dataset.path); } | |
| else if (e.key === 'ContextMenu' || (e.shiftKey && e.key === 'F10')) { | |
| e.preventDefault(); | |
| const r = row.getBoundingClientRect(); | |
| openTreeMenu(r.left + 12, r.bottom, row.dataset.path, row.dataset.kind); | |
| } | |
| }); | |
| tree.addEventListener('focusin', e => { const row = e.target.closest?.('summary, .file'); if (row) setRoving(row); }); | |
| } | |
| // resuelve el handle de un directorio por su ruta (segmentos desde la raíz) | |
| async function dirByPath(path) { | |
| let dir = code.handle(); | |
| for (const s of (path || '').split('/').filter(Boolean)) dir = await dir.getDirectoryHandle(s); | |
| return dir; | |
| } | |
| const parentOf = p => p.includes('/') ? p.slice(0, p.lastIndexOf('/')) : ''; | |
| const baseOf = p => p.split('/').pop(); | |
| async function fsCreate(parentPath, name, isDir) { | |
| const dir = await dirByPath(parentPath); | |
| if (isDir) await dir.getDirectoryHandle(name, { create: true }); | |
| else { const fh = await dir.getFileHandle(name, { create: true }); const w = await fh.createWritable(); await w.close(); } | |
| } | |
| async function fsDelete(path, kind) { | |
| const dir = await dirByPath(parentOf(path)); | |
| await dir.removeEntry(baseOf(path), { recursive: kind === 'directory' }); | |
| } | |
| // copia recursiva (la File System API no tiene rename nativo). El fichero se | |
| // copia como Blob, no como texto: pasarlo por .text() estropeaba cualquier | |
| // binario (una imagen, un .zip) al renombrarlo. | |
| async function fsCopy(srcDir, name, dstDir, newName) { | |
| const src = await (srcDir.getDirectoryHandle(name).catch(() => null)); | |
| if (src) { // directorio | |
| const nd = await dstDir.getDirectoryHandle(newName, { create: true }); | |
| for await (const e of src.values()) await fsCopy(src, e.name, nd, e.name); | |
| } else { // fichero | |
| const file = await (await srcDir.getFileHandle(name)).getFile(); | |
| const fh = await dstDir.getFileHandle(newName, { create: true }); | |
| const w = await fh.createWritable(); await w.write(file); await w.close(); | |
| } | |
| } | |
| async function fsRename(path, kind, newName) { | |
| const parent = await dirByPath(parentOf(path)); | |
| await fsCopy(parent, baseOf(path), parent, newName); | |
| await parent.removeEntry(baseOf(path), { recursive: kind === 'directory' }); | |
| } | |
| // Lo que cuelga de `path` (el fichero o todo lo que hay dentro de la carpeta). | |
| const under = (p, path, kind) => kind === 'directory' ? p.startsWith(path + '/') : p === path; | |
| // Renombrar mueve también las pestañas abiertas: antes seguían apuntando a la | |
| // ruta vieja, y guardar recreaba el fichero con el nombre antiguo. | |
| function renameTabs(path, nuevo, kind) { | |
| for (const tb of tabs) if (under(tb.path, path, kind)) { | |
| const np = kind === 'directory' ? nuevo + tb.path.slice(path.length) : nuevo; | |
| if (active === tb.path) { active = np; code.setCurrentFile(np); } | |
| tb.path = np; | |
| } | |
| for (const d of [...openDirs]) if (d === path || d.startsWith(path + '/')) { openDirs.delete(d); openDirs.add(nuevo + d.slice(path.length)); } | |
| renderTabs(); | |
| } | |
| // Borrar cierra sus pestañas. Si una tenía cambios sin guardar no se tira: se | |
| // queda abierta y marcada (guardarla vuelve a crear el fichero). | |
| function dropTabs(path, kind) { | |
| for (let i = tabs.length - 1; i >= 0; i--) { | |
| if (!under(tabs[i].path, path, kind)) continue; | |
| if (tabs[i].dirty) tabs[i].deleted = true; | |
| else closeTabNow(i); | |
| } | |
| for (const d of [...openDirs]) if (d === path || d.startsWith(path + '/')) openDirs.delete(d); | |
| renderTabs(); | |
| applyView(); | |
| } | |
| function openTreeMenu(x, y, path, kind) { | |
| document.getElementById('tree-menu')?.remove(); | |
| const volver = document.activeElement; | |
| const menu = document.createElement('div'); | |
| menu.id = 'tree-menu'; | |
| menu.style.cssText = `position:fixed;left:${x}px;top:${y}px;z-index:200`; | |
| // en un fichero, el "aquí dentro" es su carpeta; en carpeta/raíz, ella misma | |
| const container = kind === 'file' ? parentOf(path) : path; | |
| const items = []; | |
| items.push([t('tmNewFile'), async () => { | |
| const name = prompt(t('promptNewFile')); if (!name?.trim()) return; | |
| if (container) openDirs.add(container); | |
| await fsCreate(container, name.trim(), false); code.invalidateFileList?.(); | |
| await refreshTree(); openFile(container ? container + '/' + name.trim() : name.trim()); | |
| }]); | |
| items.push([t('tmNewFolder'), async () => { | |
| const name = prompt(t('promptNewFolder')); if (!name?.trim()) return; | |
| if (container) openDirs.add(container); | |
| await fsCreate(container, name.trim(), true); code.invalidateFileList?.(); await refreshTree(); | |
| alertBar(t('created', { name: name.trim() })); | |
| }]); | |
| if (path) { | |
| if (kind === 'file') items.push([t('tmOpen'), () => openFile(path)]); | |
| if (kind === 'file' && PREVIEWABLE.has(langOf(path))) items.push([t('tmPreview'), () => togglePreview(path)]); | |
| items.push([t('tmRename'), async () => { | |
| const name = prompt(t('promptRename'), baseOf(path))?.trim(); if (!name || name === baseOf(path)) return; | |
| const nuevo = (parentOf(path) ? parentOf(path) + '/' : '') + name; | |
| await fsRename(path, kind, name); code.invalidateFileList?.(); | |
| renameTabs(path, nuevo, kind); | |
| await refreshTree(); | |
| alertBar(t('renamed', { from: baseOf(path), to: name })); | |
| }]); | |
| items.push([t('tmDelete'), async () => { | |
| if (!confirm(t('confirmDelete', { name: baseOf(path) }))) return; | |
| await fsDelete(path, kind); code.invalidateFileList?.(); | |
| dropTabs(path, kind); | |
| await refreshTree(); | |
| alertBar(t('deleted', { name: baseOf(path) })); | |
| }, 'danger']); | |
| } | |
| let close = () => menu.remove(); | |
| for (const [label, fn, cls] of items) { | |
| const b = menuButton(label, fn, cls); | |
| b.onclick = async () => { close(); try { await fn(); } catch (err) { alert(t('opFailed', { e: err.message })); } }; | |
| menu.appendChild(b); | |
| } | |
| document.body.appendChild(menu); | |
| close = wireMenu(menu, volver); | |
| } | |
| const TREE_MAX_ENTRIES = 200; | |
| async function renderDir(dir, prefix) { | |
| const ul = document.createElement('ul'); | |
| if (prefix) ul.setAttribute('role', 'group'); | |
| const entries = []; | |
| for await (const e of dir.values()) if (!IGNORE.has(e.name)) entries.push(e); | |
| entries.sort((a, b) => (a.kind !== b.kind) ? (a.kind === 'directory' ? -1 : 1) : a.name.localeCompare(b.name)); | |
| for (const e of entries.slice(0, TREE_MAX_ENTRIES)) { | |
| const li = document.createElement('li'); | |
| li.setAttribute('role', 'none'); | |
| const p = prefix ? prefix + '/' + e.name : e.name; | |
| if (e.kind === 'directory') { | |
| const det = document.createElement('details'); | |
| const sum = document.createElement('summary'); | |
| sum.innerHTML = folderIcon(); | |
| sum.appendChild(document.createTextNode(e.name)); | |
| sum.dataset.path = p; sum.dataset.kind = 'directory'; | |
| sum.setAttribute('role', 'treeitem'); | |
| sum.setAttribute('aria-expanded', 'false'); | |
| sum.tabIndex = -1; | |
| det.appendChild(sum); | |
| det.addEventListener('toggle', async () => { | |
| sum.setAttribute('aria-expanded', det.open ? 'true' : 'false'); | |
| if (det.open) openDirs.add(p); else openDirs.delete(p); | |
| if (det.open && det.children.length === 1) { | |
| det.appendChild(await renderDir(e, p)); | |
| markActive(); | |
| } | |
| }); | |
| // Estaba abierta antes del repintado: se reabre ya con su contenido. | |
| if (openDirs.has(p)) { | |
| det.appendChild(await renderDir(e, p)); | |
| det.open = true; | |
| sum.setAttribute('aria-expanded', 'true'); | |
| } | |
| li.appendChild(det); | |
| } else { | |
| const a = document.createElement('span'); | |
| a.className = 'file'; | |
| a.innerHTML = fileIcon(e.name); | |
| a.appendChild(document.createTextNode(e.name)); | |
| a.dataset.path = p; a.dataset.kind = 'file'; | |
| a.setAttribute('role', 'treeitem'); | |
| a.tabIndex = -1; | |
| a.onclick = () => openFile(p); | |
| li.appendChild(a); | |
| } | |
| ul.appendChild(li); | |
| } | |
| // Una carpeta con más de 200 entradas se cortaba sin decirlo. | |
| if (entries.length > TREE_MAX_ENTRIES) { | |
| const li = document.createElement('li'); | |
| li.className = 'tree-more'; | |
| li.setAttribute('role', 'none'); | |
| li.textContent = t('treeMore', { n: entries.length - TREE_MAX_ENTRIES }); | |
| ul.appendChild(li); | |
| } | |
| return ul; | |
| } | |
| // ---------- extensiones de VS Code (js/ext/) ---------- | |
| // Temas de color, gramáticas TextMate, snippets y lenguajes. El host solo se | |
| // carga si hay alguna extensión activa o un tema elegido, o al abrir el panel | |
| // de extensiones: sin ellas, Code arranca exactamente igual que siempre. | |
| let extCarga = null; | |
| async function hayExtensiones() { | |
| try { const p = localStorage.getItem('elffusscode.theme'); if (p && p !== 'vs-dark') return true; } catch { /* sin almacenamiento */ } | |
| const lista = await db.get('kv', 'extensions').catch(() => null); | |
| return Array.isArray(lista) && lista.some(e => e && e.enabled); | |
| } | |
| export async function loadExt(force = true) { | |
| if (ext) return ext; | |
| if (!monacoRef || (!force && !(await hayExtensiones()))) return null; | |
| extCarga ??= import('./ext/host.js').then(m => m.init(monacoRef, { onLanguagesChanged: refreshLanguages })); | |
| try { ext = await extCarga; } | |
| catch (e) { extCarga = null; console.warn('[elffuss] extensiones no disponibles:', e?.message || e); } | |
| return ext; | |
| } | |
| // Tras instalar, activar o desactivar: cada pestaña abierta, con su lenguaje y | |
| // su gramática al día (o de vuelta a lo de serie). | |
| async function refreshLanguages() { | |
| for (const tab of [...tabs]) { | |
| if (tab.model.isDisposed()) continue; | |
| const lang = await langDe(tab.path, tab.model.getLineContent(1)); | |
| await ext?.prepareLanguage(lang); | |
| if (!tab.model.isDisposed() && tab.model.getLanguageId() !== lang) monacoRef.editor.setModelLanguage(tab.model, lang); | |
| } | |
| } | |