@lincyaw/workspace 0.0.0-stage → 1.0.0-rc.0

package/src/node/site.ts

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import { basename, dirname, join, relative, resolve, sep } from 'node:path'
+import { compileTranslations, DECK_ENTRY, directoryAsset, fileHash, frontmatterLine, inside, lineOf, loadPlugins, portable, publishesDirectory, readFrontmatter, viewFor } from '@lincyaw/compiler'
+import type { Compilation } from '@lincyaw/compiler'
+import type { Finding, IRDocument, RenderContext, Renderer, SiteDocument, SiteSpec, SourcePos } from '@lincyaw/kernel'
+import type { WorkspaceDocument } from '../domain/api.ts'
+import type { WorkspaceConfig } from './config.ts'
+
+const WEB_PACKAGE = '@lincyaw/web'
+
+export async function webRenderer(root: string, bundled?: string): Promise<Renderer> {
+  const { plugins, problems } = await loadPlugins(root, [WEB_PACKAGE], { workspaceRoot: root, listed: [], bundled })
+  const renderer = plugins[0]?.plugin?.renderer
+  if (!renderer?.buildSite || !renderer.devSite) throw new Error(`the web renderer (${WEB_PACKAGE}) is not installed: ${problems.map(p => p.message).join('; ') || 'it has no workspace site'}`)
+  return renderer
+}
+
+export function siteIR(compilation: Compilation, doc: IRDocument = compilation.doc): IRDocument {
+  const dirs = doc.config.plugins.flatMap((name) => {
+    const loaded = compilation.plugins.find(plugin => plugin.name === name)
+    return loaded ? [loaded.dir] : []
+  })
+  return viewFor({ ...doc, config: { ...doc.config, plugins: dirs } }, 'web')
+}
+
+export async function siteTranslations(compilation: Compilation): Promise<{ translations: NonNullable<SiteDocument['translations']>, findings: Finding[] }> {
+  if (!compilation.doc.config.translations) return { translations: [], findings: [] }
+  const { translations, findings } = await compileTranslations(compilation)
+  return { translations: translations.map(({ lang, doc }) => ({ lang, doc: siteIR(compilation, doc) })), findings }
+}
+
+export function siteDocument(document: WorkspaceDocument, doc?: IRDocument, translations?: SiteDocument['translations']): SiteDocument {
+  return { dir: document.dir, title: document.title, ...document.lang ? { lang: document.lang } : {}, ...document.tags ? { tags: document.tags } : {}, ...doc ? { doc } : {}, ...translations?.length ? { translations } : {} }
+}
+
+export function siteSpec(config: WorkspaceConfig, documents: SiteDocument[]): SiteSpec {
+  return { title: config.title, documents, ...typeof config.site.home === 'string' ? { home: config.site.home } : {}, config: config.site }
+}
+
+const REMOTE = /^(?:[a-z][a-z\d+.-]*:|\/\/|#)/i
+
+export interface SiteContextOptions {
+  root: string
+  outDir: string
+  workDir: string
+  base?: string
+  findings: Finding[]
+}
+
+export function siteContext(options: SiteContextOptions): RenderContext {
+  const { root } = options
+  const ctx: RenderContext = {
+    deckDir: root,
+    workspaceRoot: root,
+    outDir: options.outDir,
+    workDir: options.workDir,
+    config: {},
+    extensions: [],
+    plugins: [],
+    pluginDirs: {},
+    renderers: ['web'],
+    base: options.base ?? '/',
+    vitePlugins: [],
+    extensionFor: () => undefined,
+    portable: (value, from) => portable(value, from, root),
+    localAsset: (source, url) => publishedAsset(options, source, url, ctx.report),
+    report(finding) {
+      if (!options.findings.some(f => JSON.stringify(f) === JSON.stringify(finding))) options.findings.push(finding)
+    },
+  }
+  return ctx
+}
+
+function deckOf(file: string, root: string): string | undefined {
+  for (let dir = dirname(file); inside(dir, root); dir = dirname(dir)) {
+    if (existsSync(join(dir, DECK_ENTRY))) return dir
+    if (dir === root) return undefined
+  }
+  return undefined
+}
+
+function publishedAsset(options: SiteContextOptions, source: SourcePos, url: string, report: (finding: Finding) => void): { file: string, name: string } | undefined {
+  if (REMOTE.test(url)) return undefined
+  const path = url.replace(/[?#].*$/s, '')
+  if (!path || path.startsWith('/')) return undefined
+  let name = path
+  try {
+    name = decodeURIComponent(path)
+  } catch {
+  }
+  const warn = (message: string) => report({ checkId: 'presmium.links', severity: 'warning', message, source: { file: source.file, line: lineOf(source, url) } })
+  const target = resolve(dirname(source.file), name)
+  const stat = statSync(target, { throwIfNoEntry: false })
+  if (!stat) {
+    warn(`${url} is not published: there is no such file`)
+    return undefined
+  }
+  const root = realpathSync(options.root)
+  const real = realpathSync(target)
+  if (!inside(real, root)) {
+    if (stat.isFile()) warn(`${url} is not published: the file lies outside the workspace`)
+    return undefined
+  }
+  if (stat.isFile()) return { file: target, name: `${fileHash(target).slice(0, 8)}-${basename(target)}` }
+  const deck = deckOf(source.file, options.root)
+  if (!deck || !publishesDirectory(target, deck)) return undefined
+  const lang = readFrontmatter(readFileSync(join(deck, DECK_ENTRY), 'utf8')).lang
+  return directoryAsset(target, deck, join(options.workDir, 'files'), typeof lang === 'string' ? lang : undefined, message => warn(`${url} is not published: ${message}`))
+}
+
+export function untranslated(compilation: Compilation, root: string): Finding[] {
+  const { translations } = compilation.doc.config
+  if (!translations) return []
+  const text = readFileSync(compilation.entry, 'utf8')
+  return Object.entries(translations).map(([lang, entry]) => ({
+    checkId: 'presmium.translations',
+    severity: 'warning' as const,
+    message: `translation "${lang}" (${entry}) is not in the workspace site of presmium serve, which shows the originals; presmium build at the workspace root publishes it (or presmium build ${relative(root, compilation.deckDir).split(sep).join('/') || '.'} for this document alone)`,
+    source: { file: compilation.entry, line: frontmatterLine(text, entry) },
+  }))
+}

package/src/node/source.ts

@@ -0,0 +1,148 @@
+import { createHash } from 'node:crypto'
+import { lstatSync, readdirSync, readFileSync, realpathSync } from 'node:fs'
+import { join } from 'node:path'
+import type { DocumentFileChange, Member } from '@lincyaw/kernel'
+import type { ConflictAnswer, FilesAnswer, SourceAnswer, SourceFile } from '../domain/api.ts'
+import { WORKSPACE_FILE } from '../domain/api.ts'
+import { within } from '../domain/paths.ts'
+import { listDocuments } from './config.ts'
+import type { WorkspaceConfig } from './config.ts'
+import { lockedError, RequestError } from './documents.ts'
+import { documentDirOf, writeChanges } from './files.ts'
+import type { DocumentWriter } from './files.ts'
+import type { DocumentLocks } from './locks.ts'
+
+export const MAX_SOURCE = 2 << 20
+const MAX_FILES = 2000
+const NOT_SOURCE = new Set(['node_modules', 'dist', '.git', '.presmium'])
+const BINARY = /\.(?:png|jpe?g|gif|webp|avif|ico|bmp|pdf|wasm|zip|gz|tgz|bz2|xz|7z|woff2?|ttf|otf|eot|mp3|mp4|m4a|wav|ogg|oga|webm|mov|avi|mkv|bin|so|dylib|dll|exe|pyc|xlsx?|docx?|pptx?|parquet|npy|npz|pkl|db|sqlite)$/i
+
+export function versionOf(bytes: Uint8Array | string): string {
+  return createHash('sha256').update(bytes).digest('hex').slice(0, 20)
+}
+
+export interface SourceOptions {
+  config: WorkspaceConfig
+  writer: DocumentWriter
+  locks?: DocumentLocks
+}
+
+interface Scope {
+  document: string
+  home: boolean
+}
+
+export class SourceFiles {
+  readonly #config: WorkspaceConfig
+  readonly #writer: DocumentWriter
+  readonly #locks?: DocumentLocks
+
+  constructor(options: SourceOptions) {
+    this.#config = options.config
+    this.#writer = options.writer
+    this.#locks = options.locks
+  }
+
+  scope(document: string): Scope {
+    return { document, home: document === '' && !this.#config.single }
+  }
+
+  roots(scope: Scope): string[] {
+    if (!scope.home) return [scope.document]
+    return ['']
+  }
+
+  allows(scope: Scope, path: string, member: Member): boolean {
+    if (path === WORKSPACE_FILE) return (scope.home || (this.#config.single && scope.document === '')) && member.roles.includes('owner')
+    if (scope.home && member.roles.includes('owner')) return true
+    const dir = documentDirOf(this.#config, path)
+    if (dir === undefined) return scope.home && member.roles.includes('owner')
+    return scope.home ? listDocuments(this.#config).some(doc => doc.dir === dir) : dir === scope.document
+  }
+
+  files(scope: Scope, member: Member): FilesAnswer {
+    const files: SourceFile[] = []
+    let truncated = false
+    const walk = (dir: string, owner: string | undefined) => {
+      let names: string[]
+      try {
+        names = readdirSync(join(this.#config.root, dir)).sort()
+      } catch {
+        return
+      }
+      for (const name of names) {
+        if (NOT_SOURCE.has(name) || name.startsWith('.')) continue
+        const path = dir ? `${dir}/${name}` : name
+        const found = lstatSync(join(this.#config.root, path), { throwIfNoEntry: false })
+        if (!found || found.isSymbolicLink()) continue
+        if (found.isDirectory() && (scope.home || documentDirOf(this.#config, `${path}/x`) === owner)) {
+          walk(path, owner)
+        } else if (found.isFile() && this.allows(scope, path, member)) {
+          if (files.length >= MAX_FILES) {
+            truncated = true
+            return
+          }
+          files.push({ path, ...BINARY.test(name) ? { binary: true as const } : {} })
+        }
+      }
+    }
+    walk(scope.home ? '' : scope.document, scope.home ? undefined : scope.document)
+    const documents = scope.home ? listDocuments(this.#config).map(doc => doc.dir) : undefined
+    return { document: scope.document, home: scope.home, ...documents ? { documents } : {}, files, ...truncated ? { truncated: true as const } : {} }
+  }
+
+  #bytes(scope: Scope, path: string, member: Member): Buffer {
+    if (typeof path !== 'string' || !path || path.startsWith('/') || path.includes('\0') || path.split('/').some(part => part === '' || part === '.' || part === '..' || NOT_SOURCE.has(part))) throw new RequestError(400, `not a source path: ${JSON.stringify(path)}`)
+    if (!this.allows(scope, path, member)) throw new RequestError(403, `${path} is not a file this page edits`)
+    const file = join(this.#config.root, path)
+    let real: string
+    try {
+      real = realpathSync(file)
+    } catch {
+      throw new RequestError(404, `no file ${path}`)
+    }
+    if (real !== file || !lstatSync(file).isFile()) throw new RequestError(403, `${path} is not a regular file of the workspace`)
+    const bytes = readFileSync(file)
+    if (bytes.byteLength > MAX_SOURCE) throw new RequestError(413, `${path} is larger than the editor opens (${MAX_SOURCE} bytes)`)
+    return bytes
+  }
+
+  read(scope: Scope, path: string, member: Member): SourceAnswer {
+    const bytes = this.#bytes(scope, path, member)
+    if (BINARY.test(path) || bytes.includes(0)) throw new RequestError(415, `${path} is not a text file`)
+    let content: string
+    try {
+      content = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+    } catch {
+      throw new RequestError(415, `${path} is not UTF-8 text`)
+    }
+    return { path, content, version: versionOf(bytes) }
+  }
+
+  async save(scope: Scope, path: string, content: string, base: string, member: Member): Promise<string> {
+    const document = listDocuments(this.#config).sort((a, b) => b.dir.length - a.dir.length).find(doc => within(path, doc.dir))?.dir
+    const outside = document === undefined
+    const release = outside || !this.#locks ? () => {} : this.#locks.claim(document, 'editor:save')
+    if (!release) throw lockedError(document!, this.#locks!.holder(document!) ?? '')
+    try {
+      const bytes = this.#bytes(scope, path, member)
+      const now = versionOf(bytes)
+      if (now !== base) {
+        const conflict: Omit<ConflictAnswer, 'error'> = { conflict: { version: now, content: bytes.toString('utf8') } }
+        throw new RequestError(409, `${path} changed since it was opened`, conflict)
+      }
+      const written = Buffer.from(content, 'utf8')
+      if (written.byteLength > MAX_SOURCE) throw new RequestError(413, `the text is larger than the editor saves (${MAX_SOURCE} bytes)`)
+      const change: DocumentFileChange = { path, content: written, ...(lstatSync(join(this.#config.root, path)).mode & 0o111) !== 0 ? { executable: true } : {} }
+      if (outside) writeChanges(this.#config, [change], true)
+      else await this.#writer.write([change])
+      return versionOf(written)
+    } finally {
+      release()
+    }
+  }
+
+  inScope(scope: Scope, path: string): boolean {
+    return this.roots(scope).some(root => root === WORKSPACE_FILE ? path === root : within(path, root))
+  }
+}

package/templates/document/default/lecture.md

@@ -0,0 +1,18 @@
+---
+title: "{{title}}"
+plugins:
+  - '@lincyaw/slidev-addon-core'   # 幻灯片形态的宿主适配：插件的组件与导出靠它
+---
+
+# 引言
+
+在这里写本讲的讲解。第一级标题开始一章，第二级标题开始一节；每节在网页中是一段，在幻灯片中是一页。
+
+:::{slide}
+- 要点一
+- 要点二
+:::
+
+# 小结
+
+本讲的要点。