@moood/render 0.1.3 → 0.1.5

package/scene.js

@@ -1,19 +1,34 @@
 // A scene as it lies in its world's repository, put together as moood does it (the scenes service's
 // layout.py): scenes/<folder>/scene.json and its code beside it — elements/<id>.js (objects[].code),
-// elements/<id>.script.js (objects[].script), script.js, lib.js, notes.md, widgets/<id>.html — and
-// the modules it lists (modules/<name>.js, .data.json, in the world's repository).
+// elements/<id>.script.js (objects[].script), script.js, lib.js, relief.js, notes.md, widgets/<id>.html — and
+// the modules it lists (modules/<name>.js, .data.json, in the world's repository). As it is on disk,
+// or as a commit of the repository has it (`ref`: a branch, a tag, a commit — the world's main, say).
+import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 
-const TOP = { script: 'script.js', lib: 'lib.js', notes: 'notes.md' };
+const TOP = { script: 'script.js', lib: 'lib.js', relief: 'relief.js', notes: 'notes.md' };
 const IN = { objects: { code: 'elements/{id}.js', script: 'elements/{id}.script.js' }, widgets: { html: 'widgets/{id}.html' } };
 
 const walk = dir => readdirSync(dir).flatMap(f => (statSync(join(dir, f)).isDirectory() ? walk(join(dir, f)) : [join(dir, f)]));
+const git = (world, ...args) => execFileSync('git', ['-C', world, ...args], { encoding: 'utf8', maxBuffer: 1 << 28, stdio: ['ignore', 'pipe', 'pipe'] });
+// a file at a commit (null: there is none) — its path from the world's folder, which may lie deeper in
+// its repository (./: from there)
+const shown = (world, ref, path) => { try { return git(world, 'show', `${ref}:./${path}`); } catch { return null; } };
 
-// the spec a scene's folder makes (an error says what is wrong with it)
-export function readScene(folder) {
-  const files = Object.fromEntries(walk(folder).map(p => [relative(folder, p).split(sep).join('/'), readFileSync(p, 'utf8')]));
-  if (!('scene.json' in files)) throw new Error(`${folder}: no scene.json`);
+// the spec a scene's folder makes (an error says what is wrong with it); `ref` — as that commit of the
+// world's repository (`world`) has it
+export function readScene(folder, { world, ref } = {}) {
+  let files;
+  if (ref) {
+    const at = relative(world, folder).split(sep).join('/');
+    try { git(world, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`); } catch { throw new Error(`${ref}: no such branch or commit in ${world}`); }
+    // (-z: the names as they are — any letters — not quoted; from the world's folder)
+    const names = git(world, 'ls-tree', '-r', '-z', '--name-only', ref, '--', `${at}/`).split('\0').filter(Boolean);
+    if (!names.length) throw new Error(`${ref}: there is no ${at} in it`);
+    files = Object.fromEntries(names.map(p => [p.slice(at.length + 1), shown(world, ref, p)]));
+  } else files = Object.fromEntries(walk(folder).map(p => [relative(folder, p).split(sep).join('/'), readFileSync(p, 'utf8')]));
+  if (!('scene.json' in files)) throw new Error(`${folder}${ref ? ` (${ref})` : ''}: no scene.json`);
   const spec = JSON.parse(files['scene.json']);
   const used = new Set(['scene.json']);
   for (const [key, name] of Object.entries(TOP)) if (name in files) { spec[key] = files[name].replace(/\n+$/, ''); used.add(name); }
@@ -31,13 +46,14 @@ export function readScene(folder) {
   return spec;
 }
 
-// the modules a scene lists, from its world's repository: {name: {code, data}}
-export function readModules(world, spec) {
+// the modules a scene lists, from its world's repository: {name: {code, data}} (`ref`: at that commit)
+export function readModules(world, spec, { ref } = {}) {
+  const read = path => (ref ? shown(world, ref, path) : existsSync(join(world, path)) ? readFileSync(join(world, path), 'utf8') : null);
   const out = {};
   for (const name of [...new Set((spec.modules || []).filter(n => typeof n === 'string'))].sort()) {
-    const code = join(world, 'modules', `${name}.js`), data = join(world, 'modules', `${name}.data.json`);
-    if (!existsSync(code)) throw new Error(`the scene lists modules/${name}.js, and there is none`);
-    out[name] = { code: readFileSync(code, 'utf8'), data: existsSync(data) ? JSON.parse(readFileSync(data, 'utf8')) : null };
+    const code = read(`modules/${name}.js`), data = read(`modules/${name}.data.json`);
+    if (code == null) throw new Error(`the scene lists modules/${name}.js, and there is none${ref ? ` at ${ref}` : ''}`);
+    out[name] = { code, data: data == null ? null : JSON.parse(data) };
   }
   return out;
 }

package/video.js

@@ -0,0 +1,66 @@
+// Frames into a video — by an ffmpeg already on this machine (nothing is downloaded): MOOOD_FFMPEG,
+// else the one on the PATH, else the one Playwright installs beside its browsers (that one writes
+// .webm only). The frames come in as JPEGs.
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, extname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+// what each kind of file is written with: the encoder it needs, and how
+const KINDS = {
+  '.mp4': ['libx264', ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '20', '-preset', 'veryfast', '-movflags', '+faststart']],
+  '.webm': ['libvpx', ['-c:v', 'libvpx', '-b:v', '4M', '-crf', '8', '-auto-alt-ref', '0']],
+  '.gif': ['gif', ['-vf', 'split[a][b];[a]palettegen[p];[b][p]paletteuse']],
+};
+export const VIDEOS = Object.keys(KINDS);
+
+// the ffmpegs here: the one asked for, the PATH's, Playwright's (beside its browsers: where it keeps
+// them on Linux, macOS or Windows, or up from the browser given)
+function ffmpegs(chromium) {
+  const found = [process.env.MOOOD_FFMPEG, 'ffmpeg'];
+  const homes = [process.env.PLAYWRIGHT_BROWSERS_PATH, join(homedir(), '.cache', 'ms-playwright'), join(homedir(), 'Library', 'Caches', 'ms-playwright'),
+    process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'ms-playwright')];
+  for (let d = chromium && dirname(chromium); d && dirname(d) !== d; d = dirname(d)) homes.push(d);
+  for (const home of homes.filter(h => h && existsSync(h))) {
+    for (const f of readdirSync(home).filter(f => f.startsWith('ffmpeg-')).sort().reverse()) {
+      for (const exe of ['ffmpeg-linux', 'ffmpeg-mac', 'ffmpeg-win64.exe']) if (existsSync(join(home, f, exe))) found.push(join(home, f, exe));
+    }
+  }
+  return [...new Set(found.filter(Boolean))];
+}
+const encoders = exe => { const r = spawnSync(exe, ['-hide_banner', '-encoders'], { encoding: 'utf8' }); return r.status === 0 ? r.stdout : null; };
+
+// a video being written to `out` at `fps` frames a second: write(jpeg) each frame, then done()
+export function video(out, fps, { chromium } = {}) {
+  const kind = KINDS[extname(out).toLowerCase()];
+  if (!kind) throw new Error(`--video: ${out} — a .mp4, .webm or .gif`);
+  const [need, how] = kind, tried = [];
+  let exe = null;
+  for (const f of ffmpegs(chromium || process.env.MOOOD_CHROMIUM)) {
+    const list = encoders(f);
+    if (list == null) continue;
+    tried.push(f);
+    if (new RegExp(`^\\s*V\\S*\\s+${need}\\s`, 'm').test(list)) { exe = f; break; }
+  }
+  if (!exe) {
+    throw new Error(tried.length
+      ? `--video: ${extname(out)} needs an ffmpeg with ${need}, and ${tried.join(', ')} ${tried.length > 1 ? 'have' : 'has'} none — write .webm, or install ffmpeg, or point MOOOD_FFMPEG at one`
+      : '--video: no ffmpeg here — install it (or point MOOOD_FFMPEG at one); Playwright\'s own (npx playwright install ffmpeg) writes .webm');
+  }
+  const p = spawn(exe, ['-hide_banner', '-loglevel', 'error', '-y', '-f', 'image2pipe', '-c:v', 'mjpeg', '-framerate', String(fps), '-i', '-', ...how, out], { stdio: ['pipe', 'ignore', 'pipe'] });
+  let said = '';
+  p.stderr.on('data', d => { said += d; });
+  // (ffmpeg gone — it could not start, or it stopped: what it said is the error, the frames' pipe
+  // closing with it is not)
+  const ended = new Promise((ok, no) => {
+    p.on('error', e => no(new Error(`--video: ffmpeg (${exe}) could not run: ${e.message}`)));
+    p.on('close', code => (code === 0 ? ok() : no(new Error(`--video: ffmpeg (${exe}) failed: ${said.trim() || `exit ${code}`}`))));
+  });
+  ended.catch(() => {});
+  p.stdin.on('error', () => {});
+  return {
+    ffmpeg: exe,
+    write: jpeg => new Promise((ok, no) => p.stdin.write(jpeg, e => (e ? ended.then(() => no(e), no) : ok()))),
+    done: async () => { p.stdin.end(); await ended; },
+  };
+}