98 lines
3.4 KiB
JavaScript
98 lines
3.4 KiB
JavaScript
import fs from "fs"
|
|
import { resolve } from "path"
|
|
|
|
/**
|
|
* Copy Monaco's AMD `min/vs` assets into the UI renderer public folder.
|
|
*
|
|
* Monaco is loaded at runtime via `/monaco/vs/loader.js`. These assets are gitignored
|
|
* and generated on demand in dev/build so the repo stays clean.
|
|
*
|
|
* @param {object} params
|
|
* @param {string} params.uiRendererRoot Absolute path to `packages/ui/src/renderer`.
|
|
* @param {(message: string) => void} [params.warn] Warning logger.
|
|
* @param {string[]} [params.sourceRoots] Optional override list of `.../monaco-editor/min/vs` roots.
|
|
*/
|
|
export function copyMonacoPublicAssets(params) {
|
|
const uiRendererRoot = params?.uiRendererRoot
|
|
if (!uiRendererRoot) {
|
|
throw new Error("copyMonacoPublicAssets: uiRendererRoot is required")
|
|
}
|
|
|
|
const warn = params?.warn ?? ((message) => console.warn(message))
|
|
const publicDir = resolve(uiRendererRoot, "public")
|
|
const destRoot = resolve(publicDir, "monaco/vs")
|
|
|
|
const candidates =
|
|
params?.sourceRoots?.length > 0
|
|
? params.sourceRoots
|
|
: [
|
|
// Workspace root hoisted deps.
|
|
resolve(process.cwd(), "node_modules/monaco-editor/min/vs"),
|
|
// UI package local deps (covers non-hoisted installs).
|
|
resolve(process.cwd(), "packages/ui/node_modules/monaco-editor/min/vs"),
|
|
]
|
|
|
|
const sourceRoot = candidates.find((p) => fs.existsSync(resolve(p, "loader.js")))
|
|
if (!sourceRoot) {
|
|
warn("Monaco source directory not found; skipping copy")
|
|
return
|
|
}
|
|
|
|
const copyRecursive = (src, dest) => {
|
|
const stat = fs.statSync(src)
|
|
if (stat.isDirectory()) {
|
|
fs.mkdirSync(dest, { recursive: true })
|
|
for (const entry of fs.readdirSync(src)) {
|
|
copyRecursive(resolve(src, entry), resolve(dest, entry))
|
|
}
|
|
return
|
|
}
|
|
fs.copyFileSync(src, dest)
|
|
}
|
|
|
|
// Keep the working tree clean; these assets are generated.
|
|
try {
|
|
fs.rmSync(destRoot, { recursive: true, force: true })
|
|
} catch {
|
|
// ignore
|
|
}
|
|
fs.mkdirSync(destRoot, { recursive: true })
|
|
|
|
// Copy core Monaco runtime.
|
|
for (const dir of ["base", "editor", "platform"]) {
|
|
const src = resolve(sourceRoot, dir)
|
|
if (fs.existsSync(src)) {
|
|
copyRecursive(src, resolve(destRoot, dir))
|
|
}
|
|
}
|
|
|
|
// loader.js is required.
|
|
copyRecursive(resolve(sourceRoot, "loader.js"), resolve(destRoot, "loader.js"))
|
|
|
|
// Copy baseline rich language packages + workers.
|
|
for (const lang of ["typescript", "html", "json", "css"]) {
|
|
const src = resolve(sourceRoot, "language", lang)
|
|
if (fs.existsSync(src)) {
|
|
copyRecursive(src, resolve(destRoot, "language", lang))
|
|
}
|
|
}
|
|
|
|
// Copy baseline basic tokenizers.
|
|
for (const lang of ["python", "markdown", "cpp", "kotlin"]) {
|
|
const src = resolve(sourceRoot, "basic-languages", lang)
|
|
if (fs.existsSync(src)) {
|
|
copyRecursive(src, resolve(destRoot, "basic-languages", lang))
|
|
}
|
|
}
|
|
|
|
// Copy monaco.contribution.js entrypoints (needed by some loads).
|
|
const monacoContribution = resolve(sourceRoot, "basic-languages", "monaco.contribution.js")
|
|
if (fs.existsSync(monacoContribution)) {
|
|
copyRecursive(monacoContribution, resolve(destRoot, "basic-languages", "monaco.contribution.js"))
|
|
}
|
|
const underscoreContribution = resolve(sourceRoot, "basic-languages", "_.contribution.js")
|
|
if (fs.existsSync(underscoreContribution)) {
|
|
copyRecursive(underscoreContribution, resolve(destRoot, "basic-languages", "_.contribution.js"))
|
|
}
|
|
}
|