elffuss-code / js /ext /host.js
KikoCis's picture
Sync with code.elffuss.com (fc5b0ba): LFM3 on our own engine, installable app, VS Code extensions, new look; README refreshed
4bd8362 verified
Raw History Blame Contribute Delete
19.1 kB
// Host de extensiones de VS Code — nivel 1: solo contribuciones declarativas
// (temas de color, gramáticas TextMate, snippets y configuración de lenguajes).
// NINGÚN JavaScript de una extensión se ejecuta aquí.
//
// El código de las extensiones (nivel 2) lo lleva ../ext2/host2.js, que solo
// se importa con alguna con su código encendido o al pedir algo de eso.
//
// ide.js lo carga solo si hay alguna extensión activa (o un tema elegido) y el
// panel lo carga al abrirse: sin extensiones, el arranque de Code no cambia.
// Cada cambio (instalar, activar, desactivar, desinstalar) deshace lo aplicado
// y lo vuelve a aplicar desde cero, de uno en uno: más simple y sin restos.
// Las gramáticas solo se rehacen si su lista cambia.
import * as store from './store.js';
import * as maindb from '../db.js';
import { BASES, builtinTheme, toMonacoTheme, toTextMateTheme, chromeCss, themeIdFor } from './themes.js';
import { registerSnippets } from './snippets.js';
import { toLanguageConfiguration, matchLanguage, firstLineCandidates } from './languages.js';
import { Grammars, canOverride } from './grammars.js';
import { uiLang } from '../i18n.js';
export const THEME_PREF = 'elffusscode.theme';
let instancia = null;
// ── primera línea (firstLine) en un Worker con tiempo tope ──
// Una expresión de un paquete puede no terminar nunca con según qué línea; en
// el hilo de la página congelaría la pestaña al abrir un fichero. El Worker
// avisa antes de probar cada expresión: si una se pasa de tiempo, se corta el
// Worker, esa expresión queda fuera hasta recargar y se repite con las demás.
const TOPE_EXPRESION_MS = 250;
const TOPE_ARRANQUE_MS = 8000; // el Worker ni contestó (no cargó)
const lentas = new Set();
const peticiones = new Map();
let trabajador = null, nPeticion = 0;
function sueltaTrabajador() {
trabajador?.terminate();
trabajador = null;
const resto = [...peticiones.values()];
peticiones.clear();
for (const p of resto) clearTimeout(p.timer);
return resto;
}
function alRecibir({ data }) {
const p = peticiones.get(data.id);
if (!p) return;
clearTimeout(p.timer);
if ('trying' in data) {
p.timer = setTimeout(() => {
const mala = p.candidatos[data.trying];
lentas.add(mala.src);
console.warn(`[elffuss-ext] la firstLine de «${mala.id}» no termina a tiempo: no se usa en esta sesión`);
for (const q of sueltaTrabajador()) firstLineEnWorker(q.candidatos, q.linea).then(q.resolve);
}, TOPE_EXPRESION_MS);
return;
}
peticiones.delete(data.id);
p.resolve(data.lang ?? null);
}
function firstLineEnWorker(candidatos, linea) {
candidatos = candidatos.filter(c => !lentas.has(c.src));
if (!candidatos.length || !linea) return Promise.resolve(null);
return new Promise(resolve => {
try {
if (!trabajador) {
trabajador = new Worker(new URL('./firstline-worker.js', import.meta.url), { type: 'module' });
trabajador.onmessage = alRecibir;
trabajador.onerror = () => { for (const q of sueltaTrabajador()) q.resolve(null); };
}
const id = ++nPeticion;
const p = { resolve, candidatos, linea, timer: null };
p.timer = setTimeout(() => { if (peticiones.get(id) === p) { peticiones.delete(id); resolve(null); } }, TOPE_ARRANQUE_MS);
peticiones.set(id, p);
trabajador.postMessage({ id, candidates: candidatos, line: linea });
} catch { resolve(null); } // sin Workers: sin detección por primera línea
});
}
export function init(monaco, opts = {}) {
instancia ??= crear(monaco, opts).catch(e => { instancia = null; throw e; });
return instancia;
}
async function crear(monaco, { onLanguagesChanged = () => {} } = {}) {
const paused = /[?&]noext\b/.test(location.search);
const sinCodigo = /[?&]noext2(?:[=&]|$)/.test(location.search);
const builtin = new Set(monaco.languages.getLanguages().map(l => l.id));
const registrados = new Set(); // lenguajes que registramos (Monaco no permite quitarlos)
const listeners = new Set();
let exts = [];
let aplicado = []; // disposables de lo aplicado
let langContribs = [];
let themeIndex = new Map(); // id de tema → { key, label, uiTheme, ext, extName }
let pref = leePref();
let actual = 'vs-dark', monacoId = 'vs-dark', uiTheme = 'vs-dark';
let n2 = null, dos = null; // ../ext2/host2.js: su carga, y ya cargado
let estilo = null;
let firmaGramaticas = '[]';
let cola = Promise.resolve(); // los cambios se aplican de uno en uno
const grammars = new Grammars(monaco, {
loadFile: store.getFile,
builtin,
// la primera gramática enciende el motor: el tema se redefine con el mapa
// de colores de TextMate antes de pintar ningún token
onActivate: () => aplicaTema(actual),
});
function leePref() { try { return localStorage.getItem(THEME_PREF) || 'vs-dark'; } catch { return 'vs-dark'; } }
function guardaPref(id) {
pref = id;
try { if (id === 'vs-dark') localStorage.removeItem(THEME_PREF); else localStorage.setItem(THEME_PREF, id); } catch { /* sin almacenamiento */ }
}
function pintaCromo(tema, id) {
if (!estilo) { estilo = document.createElement('style'); estilo.id = 'ext-theme-chrome'; document.head.appendChild(estilo); }
estilo.textContent = id === 'vs-dark' ? '' : chromeCss(tema);
}
let turnoTema = 0;
async function aplicaTema(id, { guardar = false } = {}) {
const turno = ++turnoTema;
let elegido = id, tema = null;
if (themeIndex.has(id)) {
tema = await store.getFile(themeIndex.get(id).key).catch(() => null);
if (!tema) elegido = 'vs-dark';
} else if (!BASES.includes(id)) elegido = 'vs-dark';
// flechas rápidas en el selector: solo cuenta la última petición
if (turno !== turnoTema) return actual;
tema ??= builtinTheme(elegido);
const encoded = grammars.setTheme(toTextMateTheme(tema));
let mid = elegido;
if (!tema.builtin) monaco.editor.defineTheme(elegido, toMonacoTheme(tema, encoded));
else if (encoded) {
mid = 'elffuss-tm-' + elegido;
monaco.editor.defineTheme(mid, { base: elegido, inherit: true, rules: [], colors: {}, encodedTokensColors: encoded });
}
monaco.editor.setTheme(mid);
actual = elegido;
monacoId = mid;
pintaCromo(tema, elegido);
uiTheme = tema.uiTheme;
dos?.setTheme(uiTheme);
if (guardar) guardaPref(elegido);
return elegido;
}
async function reaplica() {
for (const d of aplicado) { try { d.dispose(); } catch { /* ya fuera */ } }
aplicado = [];
const activas = paused ? [] : exts.filter(e => e.enabled);
langContribs = [];
for (const e of activas) {
for (const l of e.languages || []) {
langContribs.push(l);
if (builtin.has(l.id)) continue; // los de serie conservan su configuración
if (!registrados.has(l.id)) {
// sin firstLine: Monaco la ejecutaría en la página; la detección por
// primera línea es nuestra y va en un Worker (languageForFirstLine)
monaco.languages.register({ id: l.id, extensions: l.extensions, filenames: l.filenames, filenamePatterns: l.filenamePatterns, aliases: l.aliases, mimetypes: l.mimetypes });
registrados.add(l.id);
}
if (l.configKey) {
const conf = await store.getFile(l.configKey).catch(() => null);
if (conf) aplicado.push(monaco.languages.setLanguageConfiguration(l.id, toLanguageConfiguration(conf, monaco)));
}
}
}
const porLang = new Map();
for (const e of activas) {
for (const s of e.snippets || []) {
if (!porLang.has(s.language)) porLang.set(s.language, []);
porLang.get(s.language).push({ key: s.key, ext: e.displayName });
}
}
for (const [lang, fuentes] of porLang) {
const cargar = async () => (await Promise.all(fuentes.map(async f => ((await store.getFile(f.key)) || []).map(s => ({ ...s, ext: f.ext }))))).flat();
aplicado.push(registerSnippets(monaco, lang, cargar, s => s.ext));
}
// las gramáticas solo se rehacen si cambian: un tema nuevo no obliga a
// recompilarlas ni a repintar los ficheros con gramática
const gramaticas = activas.flatMap(e => (e.grammars || []).map(g => ({ ...g, ext: e.id })));
const firma = JSON.stringify(gramaticas.map(g => [g.key, g.language, g.scopeName]));
if (firma !== firmaGramaticas) { firmaGramaticas = firma; grammars.configure(gramaticas); }
themeIndex = new Map();
for (const e of activas) for (const t of e.themes || []) themeIndex.set(t.themeId, { ...t, ext: e.id, extName: e.displayName });
await aplicaTema(pref);
}
const emit = () => {
for (const f of listeners) { try { f(); } catch { /* un oyente roto no para al resto */ } }
try { onLanguagesChanged(); } catch { /* — */ }
};
// ── nivel 2 ──
const oyentesCodigo = new Set(); // el panel: estado del recinto
const nivelDos = () => (n2 ??= import('../ext2/host2.js').then(m => (dos = m.attach({
monaco, exts: () => exts, recarga, emit, paused, sinCodigo, listeners: oyentesCodigo, uiTheme: () => uiTheme,
}))));
const deDos = f => (...a) => nivelDos().then(d => d[f](...a));
function sincronizaCodigo() {
if (n2 || (!paused && !sinCodigo && exts.some(e => e.enabled && e.runs))) deDos('sync')().catch(e => console.warn('[elffuss-ext] nivel 2:', e?.message || e));
}
// Con alguna extensión con código instalada, la vista previa HTML de un
// fichero en el que entró texto suyo (kv «x2.touched») pregunta antes.
async function guardaVistaPrevia() {
(await import('../ide.js')).setBeforePreview(exts.some(e => e.code) ? async path => {
const marcas = await maindb.get('kv', 'x2.touched').catch(() => null);
return !marcas?.[path] || (await import('../ext2/gates.js')).allowPreview(path);
} : null);
}
function recarga() {
const r = cola.then(async () => { exts = await store.list(); await reaplica(); sincronizaCodigo(); await guardaVistaPrevia(); });
cola = r.catch(() => {});
return r.then(emit);
}
// ── arranque ──
try { await store.reconcile(); } catch (e) { console.warn('[elffuss-ext] no pude ordenar las extensiones guardadas:', e?.message || e); }
exts = await store.list().catch(() => []);
await reaplica();
sincronizaCodigo();
guardaVistaPrevia().catch(() => {});
const quitaTemasDe = id => { if (themeIndex.get(pref)?.ext === id) guardaPref('vs-dark'); };
// Instalar: lo declarativo y, con `withCode` (aceptado por el usuario), su
// código vía host2.js, con la suma SHA-256 publicada obligatoria.
async function install(src, { onProgress, confirmLarge, signal, withCode = false } = {}) {
let bytes, sha256, verified = false, source = 'file', meta = null;
const ovsx = await import('./openvsx.js');
if (src instanceof Blob) {
bytes = new Uint8Array(await src.arrayBuffer());
sha256 = await ovsx.sha256Hex(bytes);
} else {
meta = await ovsx.metadata(src.namespace, src.name, src.version || '', { signal });
({ bytes, sha256, verified } = await ovsx.download(meta, { onProgress, confirmLarge, signal, requireHash: withCode }));
source = 'open-vsx';
}
const { readVsix } = await import('./vsix.js');
const v = await readVsix(bytes, { lang: uiLang() });
if (meta && v.id !== `${meta.namespace}.${meta.name}`.toLowerCase()) {
throw Object.assign(new Error(`el paquete dice ser ${v.id}, no ${meta.namespace}.${meta.name}`), { code: 'mismatch', got: v.id, want: `${meta.namespace}.${meta.name}` });
}
const previo = exts.find(e => e.id === v.id);
const codigo = withCode ? await deDos('codeFiles')(v, bytes, previo) : null;
// lo que el usuario VERÍA: temas, snippets, resaltado de un lenguaje o los
// ajustes de uno nuevo. Un lenguaje que solo asocia extensiones de fichero
// no cambia nada en pantalla; si además el valor de la extensión es su
// código y NO se instala con él (nivel 2), instalarla sería inútil y se dice
// en vez de fingir que funciona.
const seVe = v.themes.length || v.snippets.length
|| v.grammars.some(g => g.language && !(builtin.has(g.language) && !canOverride(monaco, g.language)))
|| v.languages.some(l => l.config && !builtin.has(l.id));
if (!withCode && !seVe && v.analysis.hasCode) throw Object.assign(new Error('codeonly'), { code: 'codeonly', analysis: v.analysis, displayName: v.displayName });
if (!withCode && !v.themes.length && !v.grammars.length && !v.snippets.length && !v.languages.length) {
// declaraba cosas aplicables pero ninguna se pudo leer: no es lo mismo
// que no traer nada, y el usuario tiene que saber por qué
if (v.warnings.length) throw Object.assign(new Error('unreadable'), { code: 'unreadable', warning: v.warnings[0], warnings: v.warnings });
// solo trae código para el navegador: eso se instala desde «… y ejecutar su código»
if (typeof v.manifest.browser === 'string') throw Object.assign(new Error('code-only'), { code: 'codeonly' });
throw Object.assign(new Error('nothing-applies'), { code: 'nothing' });
}
const usados = new Set(exts.filter(e => e.id !== v.id).flatMap(e => (e.themes || []).map(t => t.themeId)));
const files = new Map();
const k = p => store.fileKey(v.id, v.version, p);
const rec = {
id: v.id, publisher: v.publisher, name: v.name, version: v.version,
displayName: v.displayName, description: v.description.slice(0, 500),
license: (meta?.license || v.license || '').slice(0, 200), sha256, verified, source, size: bytes.length,
installedAt: previo?.installedAt || Date.now(), enabled: previo ? previo.enabled : true,
hasCode: v.analysis.hasCode, browser: typeof v.manifest.browser === 'string', ignored: v.analysis.ignored, pack: v.analysis.pack, warnings: v.warnings.slice(0, 20),
categories: v.analysis.categories, sizes: v.analysis.sizes, webviews: v.analysis.webviews, browserEntry: v.analysis.browserEntry,
themes: v.themes.map(t => { const key = k('theme/' + t.index); files.set(key, t.data); return { key, label: t.label, uiTheme: t.uiTheme, themeId: themeIdFor(v.id, t, t.index, usados) }; }),
grammars: v.grammars.map(g => {
const key = k(g.path); files.set(key, g.data);
return { key, scopeName: g.scopeName, language: g.language, embeddedLanguages: g.embeddedLanguages, tokenTypes: g.tokenTypes, injectTo: g.injectTo, balancedBracketScopes: g.balancedBracketScopes, unbalancedBracketScopes: g.unbalancedBracketScopes };
}),
snippets: v.snippets.map(s => { const key = k(s.path); files.set(key, s.data); return { key, language: s.language, count: s.data.length }; }),
languages: v.languages.map(l => {
let configKey = null;
if (l.config) { configKey = k(l.configPath); files.set(configKey, l.config); }
return { id: l.id, aliases: l.aliases, extensions: l.extensions, filenames: l.filenames, filenamePatterns: l.filenamePatterns, firstLine: l.firstLine, mimetypes: l.mimetypes, configKey };
}),
licenseKey: null,
};
if (v.licenseText) { rec.licenseKey = k('LICENSE'); files.set(rec.licenseKey, v.licenseText); }
if (codigo) { for (const [key, d] of codigo.files) files.set(key, d); Object.assign(rec, codigo.fields); }
await store.put(rec, files);
await recarga();
return rec;
}
async function setEnabled(id, on) {
if (!on) quitaTemasDe(id);
await store.setEnabled(id, on);
await recarga();
}
async function uninstall(id) {
quitaTemasDe(id);
await store.remove(id);
await recarga();
}
const nombresSerie = { 'vs-dark': 'builtinDark', vs: 'builtinLight', 'hc-black': 'builtinHc', 'hc-light': 'builtinHcLight' };
return {
paused,
list: () => exts.map(e => ({ ...e })),
onChange(fn) { listeners.add(fn); return () => listeners.delete(fn); },
install, setEnabled, uninstall,
// nivel 2 (host2.js)
setRuns: deDos('setRuns'), setSettings: deDos('setSettings'), setFormatter: deDos('setFormatter'), codeRuntime: deDos('runtime'),
codeState: () => (dos ? dos.state() : { state: 'stopped', extensions: [], commands: [] }),
codeCommands: () => (dos ? dos.commands() : []),
onCodeChange(fn) { oyentesCodigo.add(fn); return () => oyentesCodigo.delete(fn); },
noCode: paused || sinCodigo,
licenseText: async id => { const e = exts.find(x => x.id === id); return e?.licenseKey ? (await store.getFile(e.licenseKey)) || '' : ''; },
themes: () => [
...BASES.map(id => ({ id, builtin: true, labelKey: nombresSerie[id], uiTheme: id })),
...[...themeIndex].map(([id, t]) => ({ id, label: t.label, uiTheme: t.uiTheme, ext: t.ext, extName: t.extName })),
],
currentTheme: () => actual,
themeId: () => monacoId,
setTheme: id => aplicaTema(id, { guardar: true }),
previewTheme: id => aplicaTema(id),
languageForPath: path => (paused ? null : matchLanguage(langContribs, path)),
// solo para ficheros que nadie reclama por su nombre (ide.js)
languageForFirstLine: line => (paused ? Promise.resolve(null) : firstLineEnWorker(firstLineCandidates(langContribs), line)),
prepareLanguage: async lang => (paused || !grammars.hasGrammarFor(lang) ? false : grammars.prepare(lang)),
skippedGrammars: () => grammars.skipped.map(g => ({ ext: g.ext, language: g.language, scopeName: g.scopeName })),
// lo que no se aplicaría aunque la extensión esté activa: la gramática de
// un lenguaje de serie sin Monarch (JSON) y la configuración de un lenguaje
// de serie (Monaco conserva la suya)
grammarSkippedFor: lang => typeof lang === 'string' && builtin.has(lang) && !canOverride(monaco, lang),
builtinLanguage: id => builtin.has(id),
// para decir en llano lo que hace cada extensión (panel.js)
languageName(id) {
for (let i = langContribs.length - 1; i >= 0; i--) if (langContribs[i].id === id && langContribs[i].aliases?.[0]) return langContribs[i].aliases[0];
return monaco.languages.getLanguages().find(l => l.id === id)?.aliases?.[0] || null;
},
languageExtensions(id) {
const out = new Set();
for (const l of langContribs) if (l.id === id) for (const x of l.extensions || []) out.add(x);
for (const x of monaco.languages.getLanguages().find(l => l.id === id)?.extensions || []) out.add(x);
return [...out];
},
async snippetPrefixes(id, n = 3) {
const e = exts.find(x => x.id === id);
const out = [];
for (const s of e?.snippets || []) {
for (const x of (await store.getFile(s.key).catch(() => null)) || []) {
if (x?.prefix && !out.includes(x.prefix)) out.push(x.prefix);
if (out.length >= n) return out;
}
}
return out;
},
async languageConfig(id, lang) {
const l = exts.find(x => x.id === id)?.languages?.find(x => x.id === lang);
return l?.configKey ? store.getFile(l.configKey).catch(() => null) : null;
},
};
}