@lincyaw/addon-publish 0.0.0-stage → 1.0.0-rc.2

package/src/node/pdf.ts

@@ -0,0 +1,18 @@
+import { readFile } from 'node:fs/promises'
+import { PDFArray, PDFDict, PDFDocument, PDFHexString, PDFName, PDFString } from 'pdf-lib'
+
+export async function pdfLinks(file: string): Promise<string[][]> {
+  const doc = await PDFDocument.load(await readFile(file), { updateMetadata: false })
+  return doc.getPages().map((page) => {
+    const annots = page.node.lookupMaybe(PDFName.of('Annots'), PDFArray)
+    const uris: string[] = []
+    for (let i = 0; i < (annots?.size() ?? 0); i++) {
+      const annot = annots!.lookupMaybe(i, PDFDict)
+      if (annot?.get(PDFName.of('Subtype')) !== PDFName.of('Link')) continue
+      const action = annot.lookupMaybe(PDFName.of('A'), PDFDict)
+      const uri = action?.lookupMaybe(PDFName.of('URI'), PDFString, PDFHexString)
+      if (uri) uris.push(uri.decodeText())
+    }
+    return uris
+  })
+}

package/src/node/presmium.ts

@@ -0,0 +1,18 @@
+import { createRequire } from 'node:module'
+import type { PresmiumNodePlugin } from '@lincyaw/kernel'
+import { PUBLISH_ID } from '../domain/index.ts'
+import { remoteAssetsPass } from './assets.ts'
+
+const { version } = createRequire(import.meta.url)('../../package.json') as { version: string }
+
+const plugin: PresmiumNodePlugin = {
+  id: PUBLISH_ID,
+  version,
+  kernel: '^1.0.0',
+  passes: [remoteAssetsPass],
+  rendererExtensions: {
+    notebook: { components: { PmContrastToggle: () => [] } },
+  },
+}
+
+export default plugin

package/src/node/process.ts

@@ -0,0 +1,39 @@
+import { execFile, spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { delimiter, dirname, join } from 'node:path'
+import { promisify } from 'node:util'
+import { forEachLine } from '@lincyaw/kernel/node'
+
+const exec = promisify(execFile)
+
+export async function git(cwd: string, ...args: string[]): Promise<string> {
+  const { stdout } = await exec('git', args, { cwd, maxBuffer: 64 << 20 })
+  return stdout.trim()
+}
+
+function binPath(dir: string): string {
+  const bins: string[] = []
+  for (let d = dir; ; d = dirname(d)) {
+    if (existsSync(join(d, 'node_modules', '.bin'))) bins.push(join(d, 'node_modules', '.bin'))
+    if (dirname(d) === d) break
+  }
+  return [...bins, process.env.PATH ?? ''].join(delimiter)
+}
+
+/** Runs `command`, its output a line at a time to `log` (else to this process's stderr); `signal` stops it. */
+export function run(cwd: string, command: string, args: string[], env: Record<string, string> = {}, options: { log?: (line: string) => void, signal?: AbortSignal } = {}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (options.signal?.aborted) return reject(options.signal.reason as Error)
+    const child = spawn(command, args, { cwd, env: { ...process.env, ...env, PATH: binPath(cwd) }, stdio: options.log ? ['ignore', 'pipe', 'pipe'] : ['ignore', 2, 2] })
+    if (options.log) for (const stream of [child.stdout, child.stderr]) forEachLine(stream, options.log)
+    const stop = () => child.kill('SIGTERM')
+    options.signal?.addEventListener('abort', stop, { once: true })
+    child.on('error', error => reject(new Error(`cannot run ${command}: ${error.message}`)))
+    child.on('close', (code) => {
+      options.signal?.removeEventListener('abort', stop)
+      if (options.signal?.aborted) reject(options.signal.reason as Error)
+      else if (code === 0) resolve()
+      else reject(new Error(`${command} ${args[0] ?? ''} exited with code ${code}`))
+    })
+  })
+}

package/src/node/visual-diff.ts

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs'
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join, relative, resolve } from 'node:path'
+import { Compiler, DECK_ENTRY, viewFor } from '@lincyaw/compiler'
+import pixelmatch from 'pixelmatch'
+import { PNG } from 'pngjs'
+import { diffReport, pageStatus, pairPages, parsePageFile, parseWebFile, reportMarkdown } from '../domain/index.ts'
+import type { DiffSide, PageRef, VisualDiff, VisualDiffReport } from '../domain/index.ts'
+import { hasForm } from './deck.ts'
+import { git, run } from './process.ts'
+import { exportSlides } from './export.ts'
+import { captureWeb } from './web-capture.ts'
+
+export interface DiffJob {
+  refA: string
+  refB: string
+  deckDir: string
+  out?: string
+  threshold?: number
+  wait?: number
+  install?: boolean
+}
+
+export async function visualDiff(job: DiffJob): Promise<{ report: VisualDiffReport, out: string, warnings: string[] }> {
+  const deckDir = resolve(job.deckDir)
+  const root = await git(deckDir, 'rev-parse', '--show-toplevel')
+  const sides = await Promise.all([job.refA, job.refB].map(async (ref): Promise<DiffSide> => {
+    const commit = await git(deckDir, 'rev-parse', '--verify', '--quiet', '--end-of-options', `${ref}^{commit}`).catch(() => '')
+    if (!commit) throw new Error(`unknown revision "${ref}"`)
+    return { ref, commit }
+  }))
+  const warnings = job.install ? [] : await outsideDeckWarnings(root, deckDir, sides[0]!.commit, sides[1]!.commit)
+
+  const work = join(deckDir, '.presmium', 'diff')
+  const out = resolve(job.out ?? work)
+  if (out !== work && existsSync(out) && (await readdir(out)).length > 0 && !existsSync(join(out, 'report.json'))) {
+    throw new Error(`${out} is not empty and holds no previous report; choose another --out`)
+  }
+  await mkdir(work, { recursive: true })
+  await writeFile(join(work, '.gitignore'), '*\n')
+  for (const dir of ['a', 'b', 'diff']) await rm(join(out, dir), { recursive: true, force: true })
+
+  const sections = new Map<string, number>()
+  for (const [label, side] of [['a', sides[0]!], ['b', sides[1]!]] as const) {
+    const checkout = join(work, `checkout-${label}`)
+    await removeWorktree(root, checkout)
+    await git(root, 'worktree', 'add', '--detach', '--force', checkout, side.commit)
+    try {
+      const deck = join(checkout, relative(root, deckDir))
+      if (!existsSync(join(deck, DECK_ENTRY))) throw new Error(`${side.ref} has no ${relative(root, join(deckDir, DECK_ENTRY))}`)
+      if (job.install) await run(lockfileDir(deck, checkout), 'pnpm', ['install', '--frozen-lockfile', '--prefer-offline'])
+      const compilation = await new Compiler(deck).compile()
+      const wait = job.wait ?? 500
+      if (hasForm(compilation, 'slides')) {
+        await exportSlides(compilation, { deckDir: deck, format: 'png', withClicks: true, output: join(out, label) })
+      }
+      if (hasForm(compilation, 'web')) {
+        for (const section of viewFor(compilation.doc, 'web').sections) sections.set(section.id, section.index)
+        warnings.push(...(await captureWeb(compilation, join(work, `web-${label}`), join(out, label, 'web'), wait)).map(w => `${side.ref}: ${w}`))
+      }
+    } finally {
+      await removeWorktree(root, checkout)
+    }
+  }
+
+  const threshold = job.threshold ?? 0
+  const pages = [...await comparePages(out, '', threshold, parsePageFile), ...await comparePages(out, 'web', threshold, name => parseWebFile(name, sections))]
+  const report = diffReport(sides[0]!, sides[1]!, threshold, pages)
+  await writeFile(join(out, 'report.json'), `${JSON.stringify(report, null, 2)}\n`)
+  await writeFile(join(out, 'report.md'), reportMarkdown(report))
+  return { report, out, warnings }
+}
+
+/** Warns of the changes between the commits outside the deck, which render from the installed packages. */
+async function outsideDeckWarnings(root: string, deckDir: string, a: string, b: string): Promise<string[]> {
+  const deck = relative(root, deckDir)
+  if (!deck) return []
+  const files = (await git(root, 'diff', '--name-only', a, b, '--', '.', `:(exclude)${deck}`)).split('\n').filter(Boolean)
+  if (files.length === 0) return []
+  const shown = files.slice(0, 3).join(', ') + (files.length > 3 ? `, … (${files.length} files)` : '')
+  return [`changes outside the deck are not rendered from their commit: ${shown}; --install renders each commit with its own dependencies`]
+}
+
+async function comparePages(out: string, dir: string, threshold: number, parse: (name: string) => PageRef | undefined): Promise<VisualDiff[]> {
+  const list = async (side: string) => (existsSync(join(out, side, dir)) ? readdir(join(out, side, dir)) : [])
+  await mkdir(join(out, 'diff', dir), { recursive: true })
+  const pages: VisualDiff[] = []
+  for (const { page, a, b } of pairPages(await list('a'), await list('b'), parse)) {
+    if (!a || !b) {
+      pages.push({ ...page, status: pageStatus(1, threshold, !!a, !!b), ratio: 1, diffPixels: 0 })
+      continue
+    }
+    const [imgA, imgB] = await Promise.all([readFile(join(out, 'a', dir, a)), readFile(join(out, 'b', dir, b))]).then(files => files.map(f => PNG.sync.read(f)))
+    const { width, height } = imgA!
+    if (width !== imgB!.width || height !== imgB!.height) {
+      pages.push({ ...page, status: pageStatus(1, threshold, true, true), ratio: 1, diffPixels: width * height })
+      continue
+    }
+    const diff = new PNG({ width, height })
+    const diffPixels = pixelmatch(imgA!.data, imgB!.data, diff.data, width, height, { threshold: 0.1 })
+    const ratio = diffPixels / (width * height)
+    if (diffPixels > 0) await writeFile(join(out, 'diff', `${page.id}.png`), PNG.sync.write(diff))
+    pages.push({ ...page, status: pageStatus(ratio, threshold, true, true), ratio, diffPixels })
+  }
+  return pages
+}
+
+function lockfileDir(deck: string, checkout: string): string {
+  for (let d = deck; ; d = dirname(d)) {
+    if (existsSync(join(d, 'pnpm-lock.yaml'))) return d
+    if (d === checkout || dirname(d) === d) throw new Error('--install needs a pnpm-lock.yaml in the checked-out commit')
+  }
+}
+
+async function removeWorktree(root: string, dir: string): Promise<void> {
+  if (!existsSync(dir)) return
+  await git(root, 'worktree', 'remove', '--force', dir).catch(() => undefined)
+  await rm(dir, { recursive: true, force: true })
+}

package/src/node/web-capture.ts

@@ -0,0 +1,51 @@
+import { mkdir, readdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { build, playwrightChromium, serveDirectory, viewFor } from '@lincyaw/compiler'
+import type { Compilation } from '@lincyaw/compiler'
+
+interface Chromium {
+  launch(): Promise<{
+    newPage(options: Record<string, unknown>): Promise<{
+      goto(url: string, options: { waitUntil: 'networkidle' }): Promise<unknown>
+      waitForSelector(selector: string): Promise<unknown>
+      waitForTimeout(ms: number): Promise<void>
+      screenshot(options: { path: string, fullPage?: boolean }): Promise<unknown>
+    }>
+    close(): Promise<void>
+  }>
+}
+
+export async function captureWeb(compilation: Compilation, out: string, dir: string, wait: number): Promise<string[]> {
+  await rm(out, { recursive: true, force: true })
+  const report = await build(compilation, { outDir: out, to: ['web'] })
+  const web = report.outputs.find(o => o.renderer === 'web')
+  if (!web) return [`the web form was not built: ${report.findings.filter(f => f.severity === 'error').map(f => f.message).join('; ') || 'no web renderer'}`]
+  await mkdir(dir, { recursive: true })
+  const server = await serveDirectory(web.outDir, { base: web.base })
+  try {
+    const site = `${server.url}${web.base}`
+    const browser = await (await playwrightChromium<Chromium>(compilation.deckDir)).launch()
+    try {
+      const page = await browser.newPage({ viewport: { width: 1280, height: 800 }, reducedMotion: 'reduce', serviceWorkers: 'block' })
+      const pages = (await readdir(web.outDir)).filter(file => file.endsWith('.html') && file !== '404.html').sort()
+      for (const file of pages) {
+        await page.goto(`${site}${file}`, { waitUntil: 'networkidle' })
+        await page.waitForSelector('.pm-section')
+        await page.waitForTimeout(wait)
+        await page.screenshot({ path: join(dir, `${file.slice(0, -'.html'.length)}.png`), fullPage: true })
+      }
+      for (const section of viewFor(compilation.doc, 'web').sections) {
+        await page.goto(`${site}?view=present&section=${encodeURIComponent(section.id)}`, { waitUntil: 'networkidle' })
+        await page.waitForSelector(`.pm-present[data-section=${JSON.stringify(section.id)}]`)
+        await page.waitForTimeout(wait)
+        await page.screenshot({ path: join(dir, `present-${section.id}.png`) })
+      }
+    } finally {
+      await browser.close()
+    }
+  } finally {
+    try { await server.close() }
+    finally { await rm(out, { recursive: true, force: true }) }
+  }
+  return report.findings.filter(f => f.severity !== 'info').map(f => f.message)
+}