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

package/src/node/publish.ts

@@ -1,17 +1,22 @@
+import { createHash } from 'node:crypto'
 import { statSync } from 'node:fs'
 import { join } from 'node:path'
-import { irBlocks, mapHtmlUrls, publishedUrl, withProp } from '@lincyaw/kernel'
-import type { DocumentLink, IRBlock, IRDocument, LocalAsset, MdastNode, RenderContext, SourcePos } from '@lincyaw/kernel'
-import { copyPublished } from '@lincyaw/kernel/node'
+import { irBlocks, mapHtmlUrls, NON_FILE_URL, publishedUrl, withPublishedAssets } from '@lincyaw/kernel'
+import type { DocumentLink, IRBlock, IRDocument, IRSection, LocalAsset, MdastNode, RenderContext, SourcePos } from '@lincyaw/kernel'
+import { copyPublished, fileVersion } from '@lincyaw/kernel/node'
 import katex from 'katex'
 
 export const MEDIA = 'media'
 
+/** The IR revision of an IR written as JSON. */
+export function irRevisionOfJson(json: string): string {
+  return createHash('sha256').update(json).digest('hex').slice(0, 16)
+}
+
 const LINKED = new Set(['image', 'link', 'definition', 'card'])
 
 interface Asset extends LocalAsset {
-  size: number
-  mtimeMs: number
+  version: string
 }
 
 const assets = new Map<string, Asset>()
@@ -19,21 +24,22 @@ const assets = new Map<string, Asset>()
 function localAsset(ctx: RenderContext, source: SourcePos, url: string): Asset | undefined {
   const key = `${source.file}\0${url}`
   const known = assets.get(key)
-  const now = known && statSync(known.file, { throwIfNoEntry: false })
-  if (known && now && now.size === known.size && now.mtimeMs === known.mtimeMs) return known
+  const now = known && statSync(known.file, { bigint: true, throwIfNoEntry: false })
+  if (known && now && fileVersion(now) === known.version) return known
   const found = ctx.localAsset(source, url)
-  const stat = found && statSync(found.file, { throwIfNoEntry: false })
+  const stat = found && statSync(found.file, { bigint: true, throwIfNoEntry: false })
   if (!found || !stat) {
     assets.delete(key)
     return undefined
   }
-  const asset = { ...found, size: stat.size, mtimeMs: stat.mtimeMs, directory: found.directory ?? stat.isDirectory() }
+  const asset = { ...found, version: fileVersion(stat), directory: found.directory ?? stat.isDirectory() }
   if (asset.directory) assets.delete(key)
   else assets.set(key, asset)
   return asset
 }
 
 const rendered = new Map<string, string>()
+const PUBLICATION_CACHE_BYTES = 16 << 20
 
 function renderMath(tex: string, display: boolean): string {
   const key = `${display ? 'D' : 'I'}${tex}`
@@ -47,9 +53,52 @@ function renderMath(tex: string, display: boolean): string {
 
 export type DocumentPage = (link: DocumentLink) => string | undefined
 
-export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir: string, base: string, documentPage?: DocumentPage): IRDocument {
+export class PublicationCache {
+  readonly #sections = new Map<string, { key: string, section: IRSection, bytes: number }>()
+  #bytes = 0
+
+  lookup(section: IRSection): { key: string, section?: IRSection } {
+    const key = JSON.stringify(section)
+    const known = this.#sections.get(section.id)
+    return { key, ...known?.key === key ? { section: known.section } : {} }
+  }
+
+  store(original: IRSection, key: string, section: IRSection): void {
+    const old = this.#sections.get(original.id)
+    if (old) this.#bytes -= old.bytes
+    this.#sections.delete(original.id)
+    // Local files and raw HTML can change independently of the IR. Revisit them.
+    const local = (node: MdastNode): boolean => node.type === 'html'
+      || (LINKED.has(node.type) && typeof node.url === 'string' && !NON_FILE_URL.test(node.url))
+      || Boolean(node.children?.some(local))
+    for (const block of irBlocks(original.blocks)) {
+      if (block.node.type === 'markdown' && local(block.node.mdast)) return
+      if (block.node.type === 'component' && (Object.keys(block.node.assets ?? {}).length || (block.node.fallback && local(block.node.fallback)))) return
+      if (block.stepStates?.some(state => Object.keys(state.assets ?? {}).length)) return
+    }
+    const bytes = (key.length + JSON.stringify(section).length) * 2
+    if (bytes > PUBLICATION_CACHE_BYTES) return
+    this.#sections.set(original.id, { key, section, bytes })
+    this.#bytes += bytes
+    while (this.#bytes > PUBLICATION_CACHE_BYTES || this.#sections.size > 2048) {
+      const first = this.#sections.keys().next().value!
+      this.#bytes -= this.#sections.get(first)!.bytes
+      this.#sections.delete(first)
+    }
+  }
+
+  prune(ids: Set<string>): void {
+    for (const [id, entry] of this.#sections) {
+      if (ids.has(id)) continue
+      this.#sections.delete(id)
+      this.#bytes -= entry.bytes
+    }
+  }
+}
+
+export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir: string, base: string, documentPage?: DocumentPage, cache?: PublicationCache): IRDocument {
   const { deckDir } = ctx
-  const copy = structuredClone(doc)
+  const copy: IRDocument = structuredClone(cache ? { ...doc, sections: [] } : doc)
   const media = join(publicDir, MEDIA)
   const relative = (pos: { file: string }) => {
     pos.file = ctx.portable(pos.file, deckDir) as string
@@ -73,20 +122,39 @@ export function publishedDocument(doc: IRDocument, ctx: RenderContext, publicDir
     if (node.type === 'markdown') mdast(node.mdast, source)
     if (node.type === 'component') {
       if (node.fallback) mdast(node.fallback, source)
-      for (const [path, url] of Object.entries(node.assets ?? {})) {
-        const published = publish(url, source)
-        if (published) node.props = withProp(node.props, path, published)
+      for (const state of b.stepStates ?? []) {
+        if (!state.parameters) continue
+        // Plugins can declare state-only resources. Other components inherit
+        // their declared asset paths, resolved against the current parameters.
+        const assets = state.assets ?? Object.fromEntries(Object.entries(node.assets ?? {}).flatMap(([path, original]) => {
+          const at = (props: Record<string, unknown>) => path.split('.').reduce<unknown>((current, key) => current && typeof current === 'object' ? (current as Record<string, unknown>)[key] : undefined, props)
+          const value = at(state.parameters!)
+          return typeof value === 'string' ? [[path, value !== at(node.props) ? value : original]] : []
+        }))
+        state.parameters = withPublishedAssets({ ...node, props: state.parameters, assets }, url => publish(url, source)).props
       }
+      node.props = withPublishedAssets(node, url => publish(url, source)).props
     }
   }
   copy.meta.entry = ctx.portable(copy.meta.entry, deckDir) as string
   copy.config.presmium = ctx.portable(copy.config.presmium, deckDir) as IRDocument['config']['presmium']
-  for (const section of copy.sections) {
+  for (const original of cache ? doc.sections : copy.sections) {
+    const known = cache?.lookup(original)
+    if (known?.section) {
+      copy.sections.push(known.section)
+      continue
+    }
+    const section = cache ? structuredClone(original) : original
     relative(section.source)
     if (section.config) section.config = ctx.portable(section.config, deckDir) as typeof section.config
     for (const b of irBlocks(section.blocks)) block(b)
     for (const b of irBlocks(section.blocks)) relative(b.source)
+    if (cache) {
+      copy.sections.push(section)
+      cache.store(original, known!.key, section)
+    }
   }
+  cache?.prune(new Set(doc.sections.map(section => section.id)))
   for (const finding of copy.diagnostics) {
     if (finding.source) relative(finding.source)
   }

package/src/node/renderer.ts

@@ -1,122 +1,52 @@
-import { rmSync } from 'node:fs'
 import { join, resolve } from 'node:path'
-import { irBlocks } from '@lincyaw/kernel'
-import type { IRDocument, RenderContext, Renderer } from '@lincyaw/kernel'
-import { diffDocuments } from '@lincyaw/viewer/domain'
+import type { IRDocument, RenderContext, RenderDevServer, Renderer, SiteDevServer, SiteDocument, SiteSpec } from '@lincyaw/kernel'
 import launchEditor from 'launch-editor'
-import { offlineEnabled, rendererConfig } from '../domain/index.ts'
-import type { WebRendererConfig } from '../domain/index.ts'
-import { clientModules, nodeVitePlugins } from './addons.ts'
-import type { ClientModules } from './addons.ts'
-import { writeServiceWorker } from './offline.ts'
-import { publishedDocument, publishedFile } from './publish.ts'
-import type { DocumentPage } from './publish.ts'
-import { siteFiles, write, writeSite } from './site.ts'
-import type { WorkspaceOptions } from './site.ts'
-import { buildSite, devSite } from './sites.ts'
-import { revisionOf } from './vite.ts'
-import { vitepressBuild, vitepressDev } from './vitepress.ts'
+import { rendererConfig } from '../domain/index.ts'
+import { buildSite as buildPages } from './site-build.ts'
+import type { BuiltDocument } from './site-build.ts'
+import { documentContext, documentSourceFiles } from './site-model.ts'
+import { startSiteServer } from './site-server.ts'
+import { viewerAppCache } from './viewer-app.ts'
 
 const BUILD_DIR = '.presmium/web/build'
+const LOOPBACK = '127.0.0.1'
 
-function sourceFiles(doc: IRDocument): Set<string> {
-  const files = new Set<string>()
-  for (const section of doc.sections) {
-    files.add(section.source.file)
-    for (const block of irBlocks(section.blocks)) files.add(block.source.file)
-  }
-  return files
-}
-
-export interface DocumentSite {
-  workspace?: WorkspaceOptions
-  extra?: ClientModules
-  documentPage?: DocumentPage
-  config?: string
-}
-
-function merge(modules: ClientModules, extra?: ClientModules): ClientModules {
-  if (!extra) return modules
-  return {
-    components: new Map([...extra.components, ...modules.components]),
-    plugins: [...extra.plugins, ...modules.plugins],
-    viewers: [...extra.viewers, ...modules.viewers],
-    vite: [...extra.vite, ...modules.vite],
-    nodeVite: [...extra.nodeVite, ...modules.nodeVite],
-  }
+/** One document as a site of its own: at the root of its site path, with no home page. */
+function documentSite(doc: IRDocument, ctx: RenderContext): SiteSpec {
+  return { title: doc.meta.title, documents: [{ dir: '', title: doc.meta.title, doc, ...ctx.translations ? { translations: ctx.translations } : {} }], config: ctx.config }
 }
 
-const REMOTE = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i
-
-function headImage(doc: IRDocument, ctx: RenderContext, options: WebRendererConfig, publicDir: string, document: DocumentSite): string | undefined {
-  const image = options.shell.head?.image
-  if (!image || REMOTE.test(image)) return image
-  const published = publishedFile(ctx, publicDir, options.base, { file: document.config ?? resolve(ctx.deckDir, doc.meta.entry), line: 1 }, image)
-  return published && options.shell.sitemap ? `${options.shell.sitemap.hostname}${published}` : published
+function documentWorkDir(ctx: RenderContext, dir: string): string {
+  return join(ctx.workDir, 'documents', dir ? encodeURIComponent(dir) : '_')
 }
 
-async function prepare(doc: IRDocument, ctx: RenderContext, workDir: string, document: DocumentSite = {}) {
-  const options = rendererConfig(ctx)
-  const files = siteFiles(workDir)
-  rmSync(files.publicDir, { recursive: true, force: true })
-  const deck = { deckDir: ctx.deckDir, workspaceRoot: ctx.workspaceRoot }
-  const nodeVite = await nodeVitePlugins(ctx, doc.config.presmium, Boolean(document.workspace))
-  const publish = (d: IRDocument) => publishedDocument(d, ctx, files.publicDir, options.base, document.documentPage)
-  const image = headImage(doc, ctx, options, files.publicDir, document)
-  const site = (published: IRDocument) => writeSite(workDir, {
-    doc: published,
-    deck,
-    modules: merge(clientModules(ctx, nodeVite), document.extra),
-    options,
-    workspace: document.workspace,
-    translations: (ctx.translations ?? []).map(({ lang, doc: translated }) => ({ lang, doc: publish(translated) })),
-    image,
-    ...ctx.preview ? { preview: ctx.preview } : {},
+/** The dev server of one document (`presmium dev`): its pages, or its slides. */
+export async function devDocument(doc: IRDocument, ctx: RenderContext, form: 'web' | 'slides'): Promise<RenderDevServer> {
+  let current = doc
+  const { port } = rendererConfig(ctx)
+  const server = await startSiteServer({
+    site: () => documentSite(current, ctx),
+    form,
+    ctx,
+    cacheDir: viewerAppCache(),
+    workDir: join(ctx.outDir, 'site'),
+    document: async () => current,
+    context: () => ctx,
+    nodePlugins: () => ctx.nodeVitePlugins ?? [],
+    translations: () => (form === 'web' ? ctx.translations ?? [] : []),
+    listen: { host: LOOPBACK, port: port ?? 0 },
+    openSource(file, line) {
+      if (!documentSourceFiles(current).has(file)) return
+      launchEditor(`${resolve(ctx.deckDir, file)}:${line}`, (opened, error) => {
+        console.error(`[presmium] could not open ${opened} in an editor${error ? `: ${error}` : ''}; set $EDITOR or $LAUNCH_EDITOR`)
+      })
+    },
   })
-  return { options, files, publish, site }
-}
-
-export async function buildDocument(doc: IRDocument, ctx: RenderContext, workDir: string, document: DocumentSite = {}): Promise<void> {
-  const { options, files, publish, site } = await prepare(doc, ctx, workDir, document)
-  const published = publish(doc)
-  site(published)
-  write(join(files.publicDir, 'ir.json'), JSON.stringify(published))
-  const code = await vitepressBuild(files.root, ctx.outDir)
-  if (code !== 0) throw new Error(`vitepress build exited with code ${code}`)
-  if (offlineEnabled(doc.config.presmium)) writeServiceWorker(ctx.outDir, options.base)
-}
-
-export interface DocumentDevServer {
-  port: number
-  update(doc: IRDocument): Promise<void>
-  close(): Promise<void>
-}
-
-export async function devDocument(doc: IRDocument, ctx: RenderContext, document: DocumentSite = {}, port?: number, listen: { host?: string, signal?: AbortSignal } = {}): Promise<DocumentDevServer> {
-  const { options, files, publish, site } = await prepare(doc, ctx, ctx.outDir, document)
-  let current = publish(doc)
-  let revision = revisionOf(JSON.stringify(current))
-  site(current)
-  const server = await vitepressDev(files.root, port ?? options.port, (message) => {
-    if (message.type !== 'presmium:source' || document.workspace || !sourceFiles(current).has(message.file)) return
-    launchEditor(`${resolve(ctx.deckDir, message.file)}:${message.line}`, (file, error) => {
-      console.error(`[presmium] could not open ${file} in an editor${error ? `: ${error}` : ''}; set $EDITOR or $LAUNCH_EDITOR`)
-    })
-  }, listen)
   return {
-    port: server.port,
-    async update(next: IRDocument) {
-      const published = publish(next)
-      const update = diffDocuments(current, published)
-      site(published)
-      if (!update) {
-        if (ctx.translations?.length) server.send({ type: 'presmium:translations' })
-        return
-      }
-      const base = revision
-      current = published
-      revision = revisionOf(JSON.stringify(published))
-      server.send({ type: 'presmium:update', update, base, revision })
+    url: server.url,
+    async update(next) {
+      current = next
+      server.update('', next)
     },
     close: () => server.close(),
   }
@@ -128,20 +58,51 @@ export const renderer: Renderer = {
   support: () => 'full',
 
   async build(doc: IRDocument, ctx: RenderContext) {
-    await buildDocument(doc, ctx, join(ctx.deckDir, BUILD_DIR))
+    const work = join(ctx.deckDir, BUILD_DIR)
+    const entry: BuiltDocument = { dir: '', doc, ctx, nodePlugins: ctx.nodeVitePlugins ?? [], translations: ctx.translations ?? [] }
+    await buildPages(documentSite(doc, ctx), { ...ctx, workDir: work }, [entry])
     return { outDir: ctx.outDir, skipped: [] }
   },
 
-  async dev(doc: IRDocument, ctx: RenderContext) {
-    const server = await devDocument(doc, ctx)
-    const { base } = rendererConfig(ctx)
+  dev: (doc, ctx) => devDocument(doc, ctx, 'web'),
+
+  async buildSite(site: SiteSpec, ctx: RenderContext) {
+    const documents: BuiltDocument[] = site.documents.flatMap((entry) => {
+      if (!entry.doc) return []
+      const own = documentContext(ctx, site, entry.dir, entry.doc, join(ctx.outDir, entry.dir), documentWorkDir(ctx, entry.dir))
+      return [{ dir: entry.dir, doc: entry.doc, ctx: own, nodePlugins: entry.nodeVitePlugins ?? [], translations: entry.translations ?? [] }]
+    })
+    await buildPages(site, ctx, documents)
+    return { outDir: ctx.outDir, skipped: [] }
+  },
+
+  async devSite(site: SiteSpec, ctx: RenderContext, compile: (dir: string) => Promise<IRDocument>): Promise<SiteDevServer> {
+    const entryOf = (dir: string) => site.documents.find(entry => entry.dir === dir)
+    const host = typeof ctx.config.host === 'string' && ctx.config.host ? ctx.config.host : LOOPBACK
+    const server = await startSiteServer({
+      site: () => site,
+      ctx,
+      cacheDir: viewerAppCache(),
+      workDir: join(ctx.workDir, 'viewer'),
+      document: compile,
+      context: (dir, doc) => documentContext(ctx, site, dir, doc, documentWorkDir(ctx, dir), documentWorkDir(ctx, dir)),
+      nodePlugins: dir => entryOf(dir)?.nodeVitePlugins ?? [],
+      translations: dir => entryOf(dir)?.translations ?? [],
+      listen: { host, port: Number(ctx.config.port) || 0 },
+    })
     return {
-      url: `http://localhost:${server.port}${base}`,
-      update: next => server.update(next),
+      url: server.url,
+      async update(dir, doc) {
+        const known: SiteDocument = { dir, title: doc.meta.title, ...doc.meta.lang ? { lang: doc.meta.lang } : {}, ...Array.isArray(doc.meta.tags) ? { tags: (doc.meta.tags as unknown[]).filter((t): t is string => typeof t === 'string') } : {} }
+        const entry = entryOf(dir)
+        if (entry) Object.assign(entry, known)
+        else site.documents.push(known)
+        server.update(dir, doc)
+      },
+      target: async () => server.origin,
+      app: (dir, wait) => server.app(dir, wait),
+      warm: dir => server.warm(dir),
       close: () => server.close(),
     }
   },
-
-  buildSite,
-  devSite,
 }

package/src/node/site-assets.ts

@@ -0,0 +1,17 @@
+import { join, resolve } from 'node:path'
+import { ABSOLUTE_URL, isRecord } from '@lincyaw/kernel'
+import type { RenderContext, SiteSpec } from '@lincyaw/kernel'
+import { publishedFile } from './publish.ts'
+import { isSingle } from './site-model.ts'
+
+/** Publish shell assets from the site's configuration owner, once for every document in the site. */
+export function publishedSite(site: SiteSpec, ctx: RenderContext, outDir = ctx.outDir, base = ctx.base): SiteSpec {
+  const params = isRecord(site.config.params) ? site.config.params : undefined
+  if (!params || typeof params.logo !== 'string') return site
+  const logo = params.logo.trim()
+  const file = isSingle(site) ? resolve(ctx.deckDir, site.documents[0]!.doc?.meta.entry ?? 'lecture.json') : join(ctx.workspaceRoot, 'presmium.workspace.yaml')
+  const source = { file, line: 1 }
+  const url = ABSOLUTE_URL.test(logo) ? logo : logo.startsWith('/') ? `${ctx.base}${logo.slice(1)}` : publishedFile(ctx, outDir, base, source, logo)
+  const { logo: _source, ...rest } = params
+  return { ...site, config: { ...site.config, params: { ...rest, ...url ? { logo: url } : {} } } }
+}