Spaces:
Running
Running
Download js/ext2/classify.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 9.14 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/ext2/classify.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/ext2/classify.js
-
curl -L -o classify.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/ext2/classify.js
9.14 kB
| // Qué funcionará de una extensión en Elffuss Code, ANTES de instalarla, a | |
| // partir de su package.json (y del censo en ejecución, tested.json, si la | |
| // probamos). Lo usa el panel de extensiones para decirlo con honradez: | |
| // | |
| // · lo declarativo (nivel 1): temas, gramáticas, snippets, lenguajes, con | |
| // las mismas reglas que el «Aplica» del panel; | |
| // · código para el navegador que puede correr en el recinto (nivel 2), y si | |
| // aquí (navegador, sitio) puede; | |
| // · «necesita Node»: no está disponible en el navegador; | |
| // · lo que no aparecerá aquí (vistas, webviews, depurador…); | |
| // · si la probamos en Code y qué pasó, o que aún no. | |
| // | |
| // Es pequeño y no carga nada del recinto: viaja con el panel. | |
| import { analyzeManifest } from '../ext/vsix.js'; | |
| export const VSCODE = '1.138.0'; | |
| // Contribuciones que necesitan la interfaz completa de VS Code: aquí no salen. | |
| export const WORKBENCH = ['views', 'viewsContainers', 'viewsWelcome', 'customEditors', 'notebooks', 'notebookRenderer', 'walkthroughs', 'debuggers', | |
| 'breakpoints', 'terminal', 'taskDefinitions', 'problemMatchers', 'authentication', 'chatParticipants', 'languageModelTools', | |
| 'mcpServerDefinitionProviders', 'resourceLabelFormatters', 'statusBarItems', 'remoteHelp', 'typescriptServerPlugins']; | |
| // Eventos de activación que en Code nunca ocurren | |
| const NEVER = [/^workspaceContains:/, /^onView:/, /^onWebviewPanel:/, /^onCustomEditor:/, /^onNotebook(Serializer)?:?/, /^onDebug/, /^onTerminalProfile:/, | |
| /^onAuthenticationRequest:/, /^onChatParticipant:/, /^onWalkthrough:/, /^onOpenExternalUri:/, /^onFileSystem:/, /^onSearch:/, /^onTaskType:/, /^onRenderer:/]; | |
| // ¿satisface 1.138.0 el rango de engines.vscode? (^x.y.z, ~x.y.z, >=x.y.z, x.y.z, *) | |
| const triple = s => { const m = /^(\d+)\.(\d+|x|\*)(?:\.(\d+|x|\*))?/.exec(s); return m ? [Number(m[1]), m[2] === 'x' || m[2] === '*' ? 0 : Number(m[2]), m[3] === undefined || m[3] === 'x' || m[3] === '*' ? 0 : Number(m[3])] : null; }; | |
| const cmp = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2]; | |
| export function engineOk(range, version = VSCODE) { | |
| if (typeof range !== 'string' || !range.trim() || range.trim() === '*') return true; | |
| const v = triple(version); | |
| const r = range.trim().replace(/-[\w.]+$/, ''); | |
| let m; | |
| if ((m = /^\^\s*(.+)$/.exec(r))) { const t = triple(m[1]); return !!t && cmp(v, t) >= 0 && v[0] === t[0]; } | |
| if ((m = /^~\s*(.+)$/.exec(r))) { const t = triple(m[1]); return !!t && cmp(v, t) >= 0 && v[0] === t[0] && v[1] === t[1]; } | |
| if ((m = /^>=\s*(.+)$/.exec(r))) { const t = triple(m[1]); return !!t && cmp(v, t) >= 0; } | |
| const t = triple(r); | |
| return t ? cmp(v, t) >= 0 : true; // sin entenderlo, no se bloquea | |
| } | |
| const arr = v => (Array.isArray(v) ? v : []); | |
| function settingsCount(conf) { | |
| let n = 0; | |
| for (const c of [].concat(conf || [])) if (c && typeof c.properties === 'object' && c.properties) n += Object.keys(c.properties).length; | |
| return n; | |
| } | |
| // Opciones: `tested` (el censo en ejecución), `installed` (ids instaladas), | |
| // `builtinLanguage(id)` y `grammarSkippedFor(lang)` (las mismas reglas que el | |
| // «Aplica» del panel: el lenguaje de serie de Monaco no se registra otra vez y | |
| // la gramática de uno de serie sin Monarch no se aplica) y `canRun` (si el | |
| // nivel 2 puede arrancar en este navegador y sitio). | |
| export function classify(manifest, { tested = null, installed = new Set(), builtinLanguage = () => false, grammarSkippedFor = () => false, canRun = true } = {}) { | |
| const m = manifest && typeof manifest === 'object' ? manifest : {}; | |
| const c = m.contributes && typeof m.contributes === 'object' ? m.contributes : {}; | |
| const a = analyzeManifest(m); | |
| const id = `${m.publisher}.${m.name}`.toLowerCase(); | |
| const runtime = typeof m.browser === 'string' ? 'browser' : typeof m.main === 'string' ? 'node' : 'none'; | |
| const events = arr(m.activationEvents).filter(e => typeof e === 'string'); | |
| const neverEvents = events.filter(e => NEVER.some(r => r.test(e))); | |
| // solo eventos que nunca llegan (y ninguna otra forma de activarse) | |
| const startsNever = runtime === 'browser' && events.length > 0 && neverEvents.length === events.length && !arr(c.commands).length && !arr(c.languages).length; | |
| const deps = arr(m.extensionDependencies).filter(d => typeof d === 'string').map(d => d.toLowerCase()); | |
| const unavailable = WORKBENCH.filter(k => c[k] !== undefined && (!Array.isArray(c[k]) || c[k].length) && (typeof c[k] !== 'object' || Object.keys(c[k]).length)); | |
| // Las APIs propuestas no las enciende Code (ni VS Code fuera de sus | |
| // extensiones propias): usarlas falla, pero muchas solo las prueban y | |
| // arrancan igual. Es un aviso, no un veto; el censo dice lo que pasó. | |
| const apiProposals = arr(m.enabledApiProposals).length; | |
| const engine = engineOk(m.engines && m.engines.vscode); | |
| const census = tested && tested.results && typeof m.version === 'string' ? tested.results[`${id}@${m.version}`] || null : null; | |
| const failed = !!census && ['error', 'install-failed', 'unsupported'].includes(census.state); | |
| const started = !!census && census.state === 'active'; | |
| const reasons = []; | |
| if (runtime === 'browser' && !started) { | |
| if (!engine) reasons.push('engine'); | |
| if (startsNever) reasons.push('never'); | |
| } | |
| if (runtime === 'browser' && deps.some(d => !installed.has(d))) reasons.push('deps'); | |
| if (failed) reasons.push('census'); | |
| const warnings = runtime === 'browser' && apiProposals ? ['proposals'] : []; | |
| // lo declarativo que de verdad se aplicaría aquí (como el «Aplica» del panel) | |
| const declarative = { | |
| themes: a.applies.themes, | |
| grammars: a.grammarLangs.filter(l => !(l && grammarSkippedFor(l))).length, | |
| snippets: a.applies.snippets, | |
| languages: a.languageList.filter(l => !builtinLanguage(l.id)).length, | |
| }; | |
| const hasDeclarative = Object.values(declarative).some(Boolean); | |
| // «puede correr»: entrada de navegador y nada que lo impida de antemano, o | |
| // que el censo la vio arrancar. Si faltan dependencias aún puede | |
| // instalarse, pero se dice. | |
| const eligible = runtime === 'browser' && !failed && (started || (engine && !startsNever)); | |
| return { | |
| id, version: typeof m.version === 'string' ? m.version : '', runtime, engineOk: engine, apiProposals, startsNever, neverEvents, | |
| deps: { all: deps, missing: deps.filter(d => !installed.has(d)) }, unavailable, declarative, hasDeclarative, ignored: a.ignored, | |
| counts: { commands: arr(c.commands).length, keybindings: arr(c.keybindings).length, settings: settingsCount(c.configuration) }, | |
| census, eligible, reasons, warnings, canRun: !!canRun, | |
| // ¿algo de ella funciona en Code, aquí? (para el filtro) | |
| works: hasDeclarative || (eligible && !!canRun), | |
| pack: a.pack, | |
| }; | |
| } | |
| // Ajustes que escribe el usuario (JSON) contra los que la extensión declara | |
| // en contributes.configuration: solo claves suyas y del tipo que dice. | |
| export function contributedSettings(manifest) { | |
| const out = Object.create(null); // sin prototipo: «__proto__» no es un ajuste | |
| const conf = manifest && manifest.contributes && manifest.contributes.configuration; | |
| for (const c of [].concat(conf || [])) { | |
| if (!c || typeof c.properties !== 'object' || !c.properties) continue; | |
| for (const [k, v] of Object.entries(c.properties)) if (k !== '__proto__' && v && typeof v === 'object') out[k] = v; | |
| } | |
| return out; | |
| } | |
| const typeOf = v => (v === null ? 'null' : Array.isArray(v) ? 'array' : Number.isInteger(v) ? 'integer' : typeof v); | |
| const fits = (v, t) => t === typeOf(v) || (t === 'number' && typeof v === 'number') || (t === 'integer' && Number.isInteger(v)); | |
| export function validateSettings(manifest, text) { | |
| let v; | |
| try { v = JSON.parse(String(text ?? '').trim() || '{}'); } catch (e) { return { ok: false, errors: [{ code: 'json', detail: String(e.message || e).slice(0, 200) }] }; } | |
| if (!v || typeof v !== 'object' || Array.isArray(v)) return { ok: false, errors: [{ code: 'object' }] }; | |
| const known = contributedSettings(manifest); | |
| const errors = []; | |
| for (const [k, x] of Object.entries(v)) { | |
| const p = Object.hasOwn(known, k) ? known[k] : null; | |
| if (!p) { errors.push({ code: 'unknown', key: k }); continue; } | |
| const types = [].concat(p.type || []).filter(t => typeof t === 'string'); | |
| if (types.length && !types.some(t => fits(x, t))) { errors.push({ code: 'type', key: k, type: types.join(' | ') }); continue; } | |
| if (Array.isArray(p.enum) && p.enum.length && !p.enum.some(e => JSON.stringify(e) === JSON.stringify(x))) errors.push({ code: 'enum', key: k, list: p.enum.slice(0, 10).map(e => JSON.stringify(e)).join(', ') }); | |
| } | |
| if (JSON.stringify(v).length > 100000) errors.push({ code: 'big' }); | |
| return errors.length ? { ok: false, errors } : { ok: true, value: v }; | |
| } | |
| let censo = null; | |
| export function loadTested() { | |
| censo ??= fetch(new URL('./tested.json', import.meta.url), { cache: 'no-cache', credentials: 'same-origin' }) | |
| .then(r => (r.ok ? r.json() : null)).catch(() => null) | |
| .then(j => (j && j.schema === 1 && j.results && typeof j.results === 'object' ? j : null)); | |
| return censo; | |
| } | |