1795fb4740
The Driver's ask: one folder per BUNDLE with its ELEMENTS inside, bundles sorted by capability, highest first. The rail listed every element flat under its own capability, so a bundle's elements were scattered (gospel-resources' five screens sat in three sections). Now each capability section (5 → 1) holds the bundles whose HIGHEST capability it is, in name order; a bundle with several elements is one folder (country-posters, gospel-resources, my-upg-100-list, regions-dashboard, cities-internet), and a single-element bundle is shown as its element. Composites keep their folded composition trees. StudioTree identifies a plugin's row by a `canonical` flag rather than "depth 0", so auto-reveal opens the bundle folder above an element chosen by URL or restored tab. New folder icon; 'elementsCount' and 'elements' in all 11 studio catalogues. check:studio-rail (headless, gates:post) runs the studio's real rail code on the built manifest and asserts the layout and one canonical node per plugin (21 bundles, 33 elements); it fails on the previous rail. Also: poster.json:dpi is declared identical on purpose in check:i18n-never-translated (a unit symbol kept as-is by project decision), which had turned that gate red on main.
67 lines
4.6 KiB
JavaScript
67 lines
4.6 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* check-studio-rail — the Plugin Studio's rail is laid out like plugin-designs/. Headless.
|
|
*
|
|
* The Driver's ask (2026-09-26): one FOLDER per BUNDLE with its ELEMENTS inside, bundles sorted by
|
|
* capability, highest first. Runs the studio's REAL treeSections / compositionTrees / rowsFromManifest
|
|
* (loaded through Vite, no browser) against the BUILT manifest and asserts:
|
|
* - sections run CAP 5 → 1, and each bundle sits in the section of its HIGHEST capability, once;
|
|
* - bundles within a section are in name order;
|
|
* - a bundle with several elements is ONE folder holding all of them; a single-element bundle is its element;
|
|
* - every studio row has exactly ONE canonical node (one identity per plugin; parts only target it).
|
|
* EXIT 0 pass · 1 fail · 0 with SKIP when there is no built manifest
|
|
*/
|
|
import { readFileSync, existsSync } from 'node:fs'
|
|
import { join, resolve, dirname } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { TREE_NAME } from './_tree-name.mjs'
|
|
|
|
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
|
|
const MANIFEST = join(ROOT, 'public', TREE_NAME, 'manifest.json')
|
|
if (!existsSync(MANIFEST)) { console.log('STUDIO-RAIL: SKIP — no built manifest'); process.exit(0) }
|
|
const { createServer } = await import('vite')
|
|
const { default: vue } = await import('@vitejs/plugin-vue')
|
|
const server = await createServer({ root: ROOT, configFile: false, logLevel: 'error', appType: 'custom',
|
|
server: { middlewareMode: true, hmr: false, watch: null }, plugins: [vue({ customElement: true })],
|
|
resolve: { alias: { '@map': join(ROOT, 'library') } }, define: { __DOXA_TREE_NAME__: JSON.stringify(TREE_NAME) } })
|
|
globalThis.window = globalThis
|
|
globalThis.localStorage = { getItem: () => null, setItem() {} }
|
|
let bad = 0
|
|
const fail = (m) => { bad++; console.log(' FAIL ' + m) }
|
|
try {
|
|
const comp = (await server.ssrLoadModule('/plugin-designs/plugin-studio/plugin-studio.vue')).default
|
|
const manifest = JSON.parse(readFileSync(MANIFEST, 'utf8'))
|
|
const ctx = { manifestBundles: manifest.bundles, tr: (k) => k, cfg: {}, base: '' }
|
|
ctx.rows = comp.methods.rowsFromManifest.call(ctx, manifest)
|
|
ctx.resolveRef = (ref, fb) => comp.methods.resolveRef.call(ctx, ref, fb)
|
|
ctx.compositionTrees = comp.computed.compositionTrees.call(ctx)
|
|
const secs = comp.computed.treeSections.call(ctx)
|
|
const caps = secs.map((s) => s.cap)
|
|
if (caps.join() !== [...caps].sort((a, b) => b - a).join()) fail(`sections not CAP 5 → 1: ${caps.join(',')}`)
|
|
const byBundle = new Map()
|
|
for (const r of ctx.rows) { if (!byBundle.has(r.bundle)) byBundle.set(r.bundle, []); byBundle.get(r.bundle).push(r) }
|
|
const seen = new Map()
|
|
for (const s of secs) {
|
|
const tops = s.nodes.filter((n) => n.depth === 0)
|
|
const names = tops.map((n) => (n.folder ? n.label : ctx.rows.find((r) => r.key === n.target)?.bundle))
|
|
if (names.join() !== [...names].sort((a, b) => a.localeCompare(b)).join()) fail(`CAP ${s.cap}: bundles not in name order (${names.join(', ')})`)
|
|
for (const [i, n] of tops.entries()) {
|
|
const b = names[i]; const rows = byBundle.get(b) || []
|
|
if (seen.has(b)) fail(`bundle ${b} appears twice (CAP ${seen.get(b)} and CAP ${s.cap})`)
|
|
seen.set(b, s.cap)
|
|
const top = Math.max(...rows.map((r) => r.cap))
|
|
if (top !== s.cap) fail(`bundle ${b} (highest CAP ${top}) filed under CAP ${s.cap}`)
|
|
if (rows.length > 1) {
|
|
if (!n.folder) fail(`bundle ${b} has ${rows.length} elements but is not a folder`)
|
|
const kids = s.nodes.filter((k) => k.parent === n.id && k.canonical).map((k) => k.target).sort()
|
|
if (kids.join() !== rows.map((r) => r.key).sort().join()) fail(`folder ${b} holds ${kids.length} of its ${rows.length} elements`)
|
|
} else if (n.folder) fail(`single-element bundle ${b} is shown as a folder`)
|
|
}
|
|
}
|
|
for (const b of byBundle.keys()) if (!seen.has(b)) fail(`bundle ${b} is missing from the rail`)
|
|
const canon = secs.flatMap((s) => s.nodes.filter((n) => n.canonical))
|
|
for (const r of ctx.rows) { const c = canon.filter((n) => n.target === r.key).length; if (c !== 1) fail(`${r.key} has ${c} canonical nodes (want 1)`) }
|
|
console.log(`STUDIO-RAIL: ${byBundle.size} bundle(s), ${ctx.rows.length} element(s), ${secs.length} capability section(s); folders: ${secs.flatMap((s) => s.nodes.filter((n) => n.folder).map((n) => n.label + '(' + n.kids + ')')).join(', ')}`)
|
|
} finally { await server.close() }
|
|
if (bad) { console.log(`STUDIO-RAIL: FAIL — ${bad} problem(s).`); process.exit(1) }
|
|
console.log('STUDIO-RAIL: PASS — one folder per bundle with its elements inside, bundles grouped by their highest capability (5 → 1) and in name order, one identity per plugin.')
|