Add ability to revive rendered outputs if present

This reduces preview overhead as rendered notebook outputs will be preserved.

Full renders still render all since the output directory is cleared.

Author: dragonstyle

src/format/html/format-html-notebook-preview.ts

@@ -93,7 +93,7 @@ export const notebookPreviewer = (
     const notebookPaths = previewQueue.map((work) => (work.nbPath));
     const uniquePaths = ld.uniq(notebookPaths);
     const toRenderPaths = uniquePaths.filter((nbPath) => {
-      return services.notebook.get(nbPath) === undefined;
+      return services.notebook.get(nbPath, project) === undefined;
     });
     const haveRenderedPaths: string[] = [];
     if (toRenderPaths.length > 0 && !quiet) {
@@ -126,7 +126,7 @@ export const notebookPreviewer = (
           nbDescriptors[relative(dirname(input), nbPath)];
         const nbAbsPath = isAbsolute(nbPath) ? nbPath : join(inputDir, nbPath);
         const nbContext = services.notebook;
-        const notebook = nbContext.get(nbAbsPath);
+        const notebook = nbContext.get(nbAbsPath, project);
 
         const resolvedTitle = descriptor?.title || title || basename(nbAbsPath);
 
@@ -185,7 +185,7 @@ export const notebookPreviewer = (
           }
         }
 
-        const renderedNotebook = nbContext.get(nbAbsPath);
+        const renderedNotebook = nbContext.get(nbAbsPath, project);
         if (!renderedNotebook || !renderedNotebook[kHtmlPreview].output) {
           throw new InternalError(
             "We just ensured that notebooks had rendered previews, but the preview then didn't exist.",

src/format/jats/format-jats-postprocess.ts

@@ -35,7 +35,7 @@ export const renderSubarticlePostProcessor = (
     // for each of our articles. If needed, render any that
     // aren't already rendered.
     const subArticlesToRender = subArticles.filter((subArticle) => {
-      return services.notebook.get(subArticle.input) === undefined;
+      return services.notebook.get(subArticle.input, project) === undefined;
     });
     const total = subArticlesToRender.length;
     if (subArticlesToRender.length > 0 && !quiet) {

src/project/types/manuscript/manuscript-render.ts

@@ -101,7 +101,7 @@ export const manuscriptRenderer = (
       const result = [];
 
       // Use the executed file to render the output ipynb
-      const notebook = nbContext.get(input);
+      const notebook = nbContext.get(input, context);
       let downloadHref;
       if (!notebook || !notebook[kRenderedIPynb]) {
         progressMessage("Rendering output notebook");

src/render/notebook/notebook-context.ts

@@ -24,7 +24,9 @@ import { jatsContributor } from "./notebook-contributor-jats.ts";
 import { htmlNotebookContributor } from "./notebook-contributor-html.ts";
 import { outputNotebookContributor } from "./notebook-contributor-ipynb.ts";
 import { Format } from "../../config/types.ts";
-import { safeRemoveIfExists } from "../../core/path.ts";
+import { safeExistsSync, safeRemoveIfExists } from "../../core/path.ts";
+import { relative } from "path/mod.ts";
+import { projectOutputDir } from "../../project/project-shared.ts";
 
 const contributors: Record<RenderType, NotebookContributor | undefined> = {
   [kJatsSubarticle]: jatsContributor,
@@ -50,6 +52,7 @@ export function notebookContext(): NotebookContext {
     };
   };
 
+  // Adds a rendering of a notebook to the notebook context
   const addRendering = (
     nbAbsPath: string,
     renderType: RenderType,
@@ -66,6 +69,11 @@ export function notebookContext(): NotebookContext {
     nb[renderType].output = output;
     notebooks[nbAbsPath] = nb;
   };
+
+  // Removes a rendering of a notebook from the notebook context
+  // which includes cleaning up the files. This should only be
+  // used when the caller knows other callers will not need the
+  // notebook.
   const removeRendering = (
     nbAbsPath: string,
     renderType: RenderType,
@@ -97,6 +105,7 @@ export function notebookContext(): NotebookContext {
     }
   };
 
+  // Get a contribute for a render type
   function contributor(renderType: RenderType) {
     const contributor = contributors[renderType];
     if (contributor) {
@@ -108,6 +117,7 @@ export function notebookContext(): NotebookContext {
     }
   }
 
+  // Add metadata to a given notebook rendering
   function addMetadata(
     nbAbsPath: string,
     renderType: RenderType,
@@ -120,8 +130,60 @@ export function notebookContext(): NotebookContext {
     notebooks[nbAbsPath] = nb;
   }
 
+  function reviveOutput(
+    nbAbsPath: string,
+    renderType: RenderType,
+    nbOutputDir: string,
+  ) {
+    const contrib = contributor(renderType);
+    const outFile = contrib.outputFile(nbAbsPath);
+    const outPath = join(nbOutputDir, outFile);
+    if (safeExistsSync(outPath)) {
+      const inputTime = Deno.statSync(nbAbsPath).mtime?.valueOf() || 0;
+      const outputTime = Deno.statSync(outPath).mtime?.valueOf() || 0;
+      if (inputTime <= outputTime) {
+        addRendering(nbAbsPath, renderType, {
+          file: outPath,
+          supporting: [],
+          resourceFiles: {
+            globs: [],
+            files: [],
+          },
+        });
+      }
+    }
+  }
+
   return {
-    get: (nbAbsPath: string) => {
+    get: (nbAbsPath: string, context?: ProjectContext) => {
+      const notebook = notebooks[nbAbsPath];
+      const reviveRenders: RenderType[] = [];
+      if (notebook) {
+        // We already have a notebook, try to complete its renderings
+        // by reviving any outputs that are valid
+        [kJatsSubarticle, kHtmlPreview, kRenderedIPynb].forEach(
+          (renderTypeStr) => {
+            const renderType = renderTypeStr as RenderType;
+            if (!notebook[renderType].output) {
+              reviveRenders.push(renderType);
+            }
+          },
+        );
+      } else {
+        reviveRenders.push(kHtmlPreview);
+        reviveRenders.push(kJatsSubarticle);
+        reviveRenders.push(kRenderedIPynb);
+      }
+
+      if (context) {
+        const nbRelative = relative(context.dir, dirname(nbAbsPath));
+        const nbOutputDir = join(projectOutputDir(context), nbRelative);
+
+        // See if an up to date rendered result exists for each contributor
+        for (const renderType of reviveRenders) {
+          reviveOutput(nbAbsPath, renderType, nbOutputDir);
+        }
+      }
       return notebooks[nbAbsPath];
     },
     resolve: (

src/render/notebook/notebook-contributor-html.ts

@@ -46,8 +46,15 @@ import { Format } from "../../config/types.ts";
 export const htmlNotebookContributor: NotebookContributor = {
   resolve: resolveHtmlNotebook,
   render: renderHtmlNotebook,
+  outputFile,
 };
 
+function outputFile(
+  nbAbsPath: string,
+): string {
+  return `${basename(nbAbsPath)}.html`;
+}
+
 async function resolveHtmlNotebook(
   nbAbsPath: string,
   _token: string,

src/render/notebook/notebook-contributor-ipynb.ts

@@ -33,8 +33,15 @@ import { ipynbTitleTemplatePath } from "../../format/ipynb/format-ipynb.ts";
 export const outputNotebookContributor: NotebookContributor = {
   resolve: resolveOutputNotebook,
   render: renderOutputNotebook,
+  outputFile,
 };
 
+function outputFile(
+  nbAbsPath: string,
+): string {
+  return ipynbOutputFile(nbAbsPath);
+}
+
 function resolveOutputNotebook(
   nbAbsPath: string,
   _token: string,

src/render/notebook/notebook-contributor-jats.ts

@@ -39,8 +39,15 @@ import { Format } from "../../config/types.ts";
 export const jatsContributor: NotebookContributor = {
   resolve: resolveJats,
   render: renderJats,
+  outputFile,
 };
 
+function outputFile(
+  nbAbsPath: string,
+): string {
+  return jatsOutputFile(nbAbsPath);
+}
+
 function resolveJats(
   nbAbsPath: string,
   token: string,

src/render/notebook/notebook-types.ts

@@ -67,7 +67,7 @@ export interface NotebookTemplateMetadata extends NotebookMetadata {
 
 export interface NotebookContext {
   // Retrieves the notebook from the context.
-  get: (nbPath: string, outputFile?: string) => Notebook | undefined;
+  get: (nbPath: string, context?: ProjectContext) => Notebook | undefined;
   // Resolves the data on an executedFile into data that will
   // create a `renderType` output when rendered.
   resolve: (
@@ -105,6 +105,7 @@ export interface NotebookContext {
 }
 
 export interface NotebookContributor {
+  outputFile(nbAbsPath: string): string;
   resolve(
     nbAbsPath: string,
     token: string,