@lincyaw/compiler 1.0.0-rc.0 → 1.0.0-rc.1

package/src/build.ts

@@ -0,0 +1,101 @@
+import { mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { errorMessage } from '@lincyaw/kernel'
+import type { Finding, IRDocument, RenderOutput } from '@lincyaw/kernel'
+import { unshown } from './audience.ts'
+import { audienceCompilation } from './compiler.ts'
+import type { AudienceCompilation, Compilation } from './compiler.ts'
+import { relativeIR, WORK_DIR } from './paths.ts'
+import { planRenderRun, renderContext, renderFinding, selectRenderers, translationsFor, unsupportedBlocks, WEB, writeIR } from './renderers.ts'
+import type { InstalledRenderer } from './renderers.ts'
+import type { CompiledTranslation } from './translations.ts'
+import { viewFor } from './views.ts'
+
+export interface RendererOutput {
+  renderer: string
+  outDir: string
+  workDir: string
+  base: string
+  skipped: RenderOutput['skipped']
+}
+
+export interface BuildReport {
+  ir: string
+  outputs: RendererOutput[]
+  findings: Finding[]
+}
+
+export interface BuildOptions {
+  outDir: string
+  to?: string[]
+  audience?: string
+  quote?: boolean
+  scan?: 'outDir' | 'written'
+  /** The path every renderer's output is served at, in place of each renderer's own. */
+  base?: string
+  /** The renderers' tools' output, a line at a time (`RenderContext.log`). */
+  log?(line: string): void
+}
+
+export async function build(whole: Compilation, options: BuildOptions): Promise<BuildReport> {
+  const compilation = options.audience && options.audience !== whole.audience?.name
+    ? { ...whole, doc: whole.audienceDocument(options.audience), audience: whole.audienceCompilation(options.audience) }
+    : whole
+  const { doc } = compilation
+  const ir = await writeIR(relativeIR(doc, compilation.deckDir, compilation.workspaceRoot), options.outDir)
+  const { selected, findings } = await selectRenderers(compilation, options.to)
+  if (selected.length === 0) findings.push(renderFinding(compilation, 'warning', `no renderer available; only the IR was written to ${ir}`))
+  const run = planRenderRun(compilation, selected, true, options.base)
+  const translated = await translationsFor(compilation, run)
+  findings.push(...translated.findings)
+  const render = async ({ renderer }: InstalledRenderer) => {
+    const reported: Finding[] = []
+    const ctx = renderContext(compilation, renderer.id, join(options.outDir, renderer.id), join(compilation.deckDir, WORK_DIR, renderer.id), run, reported)
+    if (renderer.id === WEB) ctx.translations = translated.views
+    if (options.log) ctx.log = options.log
+    const view = viewFor(doc, renderer.id)
+    const unsupported = unsupportedBlocks(view, renderer, ctx.extensions)
+    try {
+      await mkdir(ctx.outDir, { recursive: true })
+      const output = await renderer.build(view, ctx)
+      const listed = new Set(output.skipped.map(s => `${s.section}#${s.block}`))
+      const result: RendererOutput = { renderer: renderer.id, outDir: output.outDir, workDir: ctx.workDir, base: ctx.base, skipped: [...output.skipped, ...unsupported.filter(s => !listed.has(`${s.section}#${s.block}`))] }
+      return { result, reported }
+    } catch (error) {
+      reported.push(renderFinding(compilation, 'error', `renderer ${renderer.id} failed: ${errorMessage(error)}`))
+      return { reported }
+    }
+  }
+  // Each renderer can start its own toolchain. Do not multiply their native pools.
+  const results: Awaited<ReturnType<typeof render>>[] = []
+  for (const renderer of selected) results.push(await render(renderer))
+  const outputs = results.flatMap(({ result }) => result ? [result] : [])
+  if (compilation.audience) {
+    const scan = audienceScan(compilation.audience, translated.translations, doc)
+    const paths = options.scan === 'written' ? [ir, ...outputs.map(output => output.outDir)] : undefined
+    findings.push(...await scan.scan(options.outDir, paths, { quote: options.quote ?? true }))
+  }
+  return { ir, outputs, findings: unique([...doc.diagnostics, ...findings, ...results.flatMap(({ reported }) => reported)]) }
+}
+
+function audienceScan(audience: AudienceCompilation, translations: CompiledTranslation[], doc: IRDocument): AudienceCompilation {
+  const kept = [doc, ...translations.map(translation => translation.doc)]
+  const left = [audience, ...translations.flatMap(translation => (translation.audience ? [translation.audience] : []))].flatMap(own => own.withheld)
+  return audienceCompilation(audience.name, unshown(left, kept))
+}
+
+function unique(findings: Finding[]): Finding[] {
+  const seen = new Set<string>()
+  return findings.filter((finding) => {
+    const key = JSON.stringify([finding.checkId, finding.severity, finding.message, finding.source?.file, finding.source?.line])
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+/** The renderers the document is made with: those its configuration names, else every installed one. */
+export async function availableRenderers(compilation: Compilation): Promise<string[]> {
+  return (await selectRenderers(compilation)).selected.map(({ renderer }) => renderer.id)
+}
+

package/src/{host.ts → compilation-actions.ts}

@@ -2,16 +2,16 @@ import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { CheckRegistry, errorMessage, irBlocks } from '@lincyaw/kernel'
 import type { CheckContext, Finding, RunResult } from '@lincyaw/kernel'
-import { frontmatterLine } from './compiler.ts'
+import { build } from './build.ts'
+import type { BuildReport } from './build.ts'
 import type { Compilation } from './compiler.ts'
-import { build } from './renderers.ts'
-import type { BuildReport } from './renderers.ts'
+import { frontmatterLine } from './source-lines.ts'
 
 export function checkContext(compilation: Compilation): CheckContext {
   return {
     deckDir: compilation.deckDir,
     workspaceRoot: compilation.workspaceRoot,
-    headmatter: compilation.frontmatter,
+    headmatter: compilation.headmatter,
     src: compilation.src,
     resolvers: compilation.resolvers,
     lock: compilation.lock.toJSON(),
@@ -20,7 +20,8 @@ export function checkContext(compilation: Compilation): CheckContext {
   }
 }
 
-export async function pluginChecks(compilation: Compilation, options: { externalLinks?: boolean } = {}): Promise<Finding[]> {
+/** The plugins' checks and the publication checks; a crashed check or a duplicate check ID becomes a finding. */
+export async function runAllChecks(compilation: Compilation, options: { externalLinks?: boolean } = {}): Promise<Finding[]> {
   const { entry } = compilation
   const text = await readFile(entry, 'utf8').catch(() => '')
   const at = (name: string) => ({ file: entry, line: frontmatterLine(text, name) })
@@ -51,6 +52,12 @@ export async function runBlock(compilation: Compilation, target: { section: stri
   return compilation.run(block.node, signal)
 }
 
-export function buildView(compilation: Compilation, options: { to?: string[], outDir?: string } = {}): Promise<BuildReport> {
-  return build(compilation, { outDir: options.outDir ?? join(compilation.deckDir, 'dist'), to: options.to })
+/** Builds the compiled document into the deck's `dist/`. */
+export function buildToDist(compilation: Compilation, options: { to?: string[] } = {}): Promise<BuildReport> {
+  return build(compilation, { outDir: join(compilation.deckDir, 'dist'), to: options.to })
+}
+
+/** What a host answers for a build: each renderer's output directory, and the findings. */
+export function buildSummary(report: BuildReport): { outputs: { renderer: string, outDir: string }[], findings: Finding[] } {
+  return { outputs: report.outputs.map(({ renderer, outDir }) => ({ renderer, outDir })), findings: report.findings }
 }

package/src/compile-queue.ts

@@ -0,0 +1,28 @@
+import { setImmediate } from 'node:timers/promises'
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+type Job = { run(): Promise<void>, interactive: boolean }
+const waiting: Job[] = []
+let running = false
+const nesting = new AsyncLocalStorage<boolean>()
+
+/** One compilation per host process. Interactive work precedes queued batch builds. */
+export function enqueueCompile<T>(run: () => Promise<T>, interactive: boolean): Promise<T> {
+  if (nesting.getStore()) return run()
+  return new Promise((resolve, reject) => {
+    waiting.push({ interactive, run: async () => { try { resolve(await nesting.run(true, run)) } catch (error) { reject(error) } } })
+    void next()
+  })
+}
+
+async function next(): Promise<void> {
+  if (running || waiting.length === 0) return
+  running = true
+  const firstInteractive = waiting.findIndex(job => job.interactive)
+  const job = waiting.splice(firstInteractive < 0 ? 0 : firstInteractive, 1)[0]!
+  try { await job.run() } finally {
+    await setImmediate()
+    running = false
+    void next()
+  }
+}