Spaces:
Running
Running
File size: 19,146 Bytes
4bd8362 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 | // 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;
},
};
}
|