@hpcc-js/observablehq-compiler 1.1.3 → 1.2.0

package/dist/index.js

@@ -6622,8 +6622,13 @@
       }
   }
   function splitModule(input) {
-      // @ts-ignore
-      return ModuleParser.parse(input, { ecmaVersion: "latest" }).cells.map(cell => input.substring(cell.start, cell.end));
+      return ModuleParser
+          .parse(input, { ecmaVersion: "latest" })
+          .cells.map((cell) => ({
+          text: input.substring(cell.start, cell.end),
+          start: cell.start,
+          end: cell.end
+      }));
   }
   function parseCell$2(input) {
       return parseCell$1(input);
@@ -6681,7 +6686,7 @@
           error
       };
   }
-  function parseOmd(_) {
+  function splitOmd(_) {
       const retVal = [];
       //  Load Markdown  ---
       const re = /(```(?:\s|\S)[\s\S]*?```)/g;
@@ -6716,20 +6721,24 @@
               return {
                   id: idx,
                   mode: "js",
-                  value: cell
+                  value: cell.text,
+                  start: cell.start,
+                  end: cell.end
               };
           })
       };
   }
   function omd2notebook(omd) {
-      const cells = parseOmd(omd);
+      const cells = splitOmd(omd);
       return {
           files: [],
           nodes: cells.map((cell, idx) => {
               return {
                   id: idx,
                   mode: cell.inlineMD ? "md" : "js",
-                  value: cell.ojs
+                  value: cell.ojs,
+                  start: cell.offset,
+                  end: cell.offset + cell.ojs.length
               };
           })
       };
@@ -6959,6 +6968,7 @@ export default function define(runtime, observer) {
       }
   }
 
+  //  Module  ---
   const isRelativePath = (path) => path[0] === ".";
   const fullUrl = (path, basePath) => isRelativePath(path) ? util.join(basePath, path) : path;
   async function importFile(relativePath, baseUrl) {
@@ -6974,14 +6984,14 @@ export default function define(runtime, observer) {
       else if (util.endsWith(relativePath, ".omd")) {
           notebook = omd2notebook(content);
       }
-      const retVal = compile(notebook, baseUrl);
-      retVal.dispose = () => { };
+      const retVal = compile(notebook, { baseUrl });
+      retVal.delete = () => { };
       retVal.write = (w) => {
           w.import(path);
       };
       return retVal;
   }
-  // @ts-ignore - use precompiled notebook from observable
+  // Import precompiled notebook from observable  ---
   async function importCompiledNotebook(partial) {
       const url = `https://api.observablehq.com/${partial[0] === "@" ? partial : `d/${partial}`}.js?v=3`;
       let impMod = {
@@ -6995,17 +7005,72 @@ export default function define(runtime, observer) {
       catch (e) {
       }
       const retVal = impMod.default;
-      retVal.dispose = () => { };
+      retVal.delete = () => { };
+      retVal.write = (w) => {
+          w.import(url);
+      };
+      return retVal;
+  }
+  // Recursive notebook parsing and compiling
+  async function importNotebook(partial) {
+      const url = `https://api.observablehq.com/document/${partial}`;
+      const notebook = fetchEx(url)
+          .then(r => {
+          return r.json();
+      }).catch(e => {
+          console.error(url);
+          console.error(e);
+      });
+      const retVal = compile(await notebook);
+      retVal.delete = () => { };
       retVal.write = (w) => {
           w.import(url);
       };
       return retVal;
   }
-  function createVariable(inspect, name, inputs, definition, inline = false) {
+  async function createModule(node, parsed, text, { baseUrl, importMode }) {
+      const otherModule = isRelativePath(parsed.src) ?
+          await importFile(parsed.src, baseUrl) :
+          importMode === "recursive" ?
+              await importNotebook(parsed.src) :
+              await importCompiledNotebook(parsed.src);
+      const importVariables = [];
+      const variables = [];
+      parsed.specifiers.forEach(spec => {
+          const viewof = spec.view ? "viewof " : "";
+          importVariables.push(createImportVariable(viewof + spec.name, viewof + spec.alias));
+          if (spec.view) {
+              importVariables.push(createImportVariable(spec.name, spec.alias));
+          }
+      });
+      const retVal = (runtime, main, inspector) => {
+          let mod = runtime.module(otherModule);
+          if (parsed.injections.length) {
+              mod = mod.derive(parsed.injections, main);
+          }
+          variables.forEach(v => v(main, inspector));
+          importVariables.forEach(v => v(main, mod));
+          return mod;
+      };
+      retVal.importVariables = importVariables;
+      retVal.variables = variables;
+      retVal.delete = () => {
+          importVariables.forEach(v => v.delete());
+          variables.forEach(v => v.delete());
+          otherModule.delete();
+      };
+      retVal.write = (w) => {
+          otherModule.write(w);
+          w.importDefine(parsed);
+      };
+      return retVal;
+  }
+  //  Variable  ---
+  function createVariable(node, inspect, name, inputs, definition, inline = false) {
       let i;
       let v;
       const retVal = (module, inspector) => {
-          i = inspect ? inspector(name) : undefined;
+          i = inspect ? inspector(name, node.id) : undefined;
           v = module.variable(i);
           if (arguments.length > 1) {
               try {
@@ -7015,9 +7080,22 @@ export default function define(runtime, observer) {
                   console.error(e === null || e === void 0 ? void 0 : e.message);
               }
           }
+          if (node.pinned) {
+              v = module.variable(inspector(name, node.id));
+              try {
+                  v.define(undefined, ["md"], md => {
+                      return md `\`\`\`js
+${node.value}
+\`\`\``;
+                  });
+              }
+              catch (e) {
+                  console.error(e === null || e === void 0 ? void 0 : e.message);
+              }
+          }
           return v;
       };
-      retVal.dispose = () => {
+      retVal.delete = () => {
           var _a;
           try {
               (_a = i === null || i === void 0 ? void 0 : i._node) === null || _a === void 0 ? void 0 : _a.remove();
@@ -7049,91 +7127,52 @@ export default function define(runtime, observer) {
           v = main.variable();
           v.import(name, alias, otherModule);
       };
-      retVal.dispose = () => {
+      retVal.delete = () => {
           v === null || v === void 0 ? void 0 : v.delete();
       };
       return retVal;
   }
-  async function createModule(parsed, text, baseUrl) {
-      const otherModule = isRelativePath(parsed.src) ?
-          await importFile(parsed.src, baseUrl) :
-          await importCompiledNotebook(parsed.src);
-      const importVariables = [];
-      const variables = [];
-      parsed.specifiers.forEach(spec => {
-          const viewof = spec.view ? "viewof " : "";
-          importVariables.push(createImportVariable(viewof + spec.name, viewof + spec.alias));
-          if (spec.view) {
-              importVariables.push(createImportVariable(spec.name, spec.alias));
-          }
-      });
-      variables.push(createVariable(true, undefined, ["md"], md => {
-          return md `\`\`\`JavaScript
-${text}
-\`\`\``;
-      }));
-      const retVal = (runtime, main, inspector) => {
-          let mod = runtime.module(otherModule);
-          if (parsed.injections.length) {
-              mod = mod.derive(parsed.injections, main);
-          }
-          variables.forEach(v => v(main, inspector));
-          importVariables.forEach(v => v(main, mod));
-          return mod;
-      };
-      retVal.importVariables = importVariables;
-      retVal.variables = variables;
-      retVal.dispose = () => {
-          importVariables.forEach(v => v.dispose());
-          variables.forEach(v => v.dispose());
-          otherModule.dispose();
-      };
-      retVal.write = (w) => {
-          otherModule.write(w);
-          w.importDefine(parsed);
-      };
-      return retVal;
-  }
-  async function createCell(node, baseUrl) {
+  // Cell  ---
+  async function createCell(node, options) {
       const modules = [];
       const variables = [];
       try {
           const text = node.mode && node.mode !== "js" ? `${node.mode}\`${encodeBacktick(node.value)}\`` : node.value;
           const parsedModule = splitModule(text);
-          for (const text of parsedModule) {
-              const parsed = parseCell(text);
+          for (const cell of parsedModule) {
+              const parsed = parseCell(cell.text);
               switch (parsed.type) {
                   case "import":
-                      modules.push(await createModule(parsed, text, baseUrl));
+                      modules.push(await createModule(node, parsed, cell.text, options));
                       break;
                   case "viewof":
-                      variables.push(createVariable(true, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
-                      variables.push(createVariable(false, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
+                      variables.push(createVariable(node, true, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
+                      variables.push(createVariable(node, false, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
                       break;
                   case "mutable":
-                      variables.push(createVariable(false, parsed.initial.id, parsed.initial.inputs, parsed.initial.func));
-                      variables.push(createVariable(false, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
-                      variables.push(createVariable(true, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
+                      variables.push(createVariable(node, false, parsed.initial.id, parsed.initial.inputs, parsed.initial.func));
+                      variables.push(createVariable(node, false, parsed.variable.id, parsed.variable.inputs, parsed.variable.func));
+                      variables.push(createVariable(node, true, parsed.variableValue.id, parsed.variableValue.inputs, parsed.variableValue.func, true));
                       break;
                   case "variable":
-                      variables.push(createVariable(true, parsed.id, parsed.inputs, parsed.func));
+                      variables.push(createVariable(node, true, parsed.id, parsed.inputs, parsed.func));
                       break;
               }
           }
       }
       catch (e) {
-          variables.push(createVariable(true, undefined, [], e.message));
+          variables.push(createVariable(node, true, undefined, [], e.message));
       }
       const retVal = (runtime, main, inspector) => {
           modules.forEach(imp => imp(runtime, main, inspector));
           variables.forEach(v => v(main, inspector));
       };
-      retVal.id = "" + node.id;
+      retVal.id = node.id;
       retVal.modules = modules;
       retVal.variables = variables;
-      retVal.dispose = () => {
-          variables.forEach(v => v.dispose());
-          modules.forEach(mod => mod.dispose());
+      retVal.delete = () => {
+          variables.forEach(v => v.delete());
+          modules.forEach(mod => mod.delete());
       };
       retVal.write = (w) => {
           modules.forEach(imp => imp.write(w));
@@ -7141,14 +7180,14 @@ ${text}
       };
       return retVal;
   }
-  function createFile(file, baseUrl) {
+  //  File  ---
+  function createFile(file, options) {
       function toString() { return globalThis.url; }
-      return [file.name, { url: new URL(fullUrl(file.url, baseUrl)), mimeType: file.mime_type, toString }];
+      return [file.name, { url: new URL(fullUrl(file.url, options.baseUrl)), mimeType: file.mime_type, toString }];
   }
-  async function compile(notebook, baseUrl = ".") {
-      const files = notebook.files.map(f => createFile(f, baseUrl));
+  function notebook(_files = [], _cells = [], { baseUrl = ".", importMode = "precompiled" } = {}) {
+      const files = _files.map(f => createFile(f, { baseUrl, importMode }));
       const fileAttachments = new Map(files);
-      const _cells = await Promise.all(notebook.nodes.map(n => createCell(n, baseUrl)));
       const cells = new Map(_cells.map(c => [c.id, c]));
       const retVal = (runtime, inspector) => {
           const main = runtime.module();
@@ -7164,25 +7203,29 @@ ${text}
       };
       retVal.fileAttachments = fileAttachments;
       retVal.cells = cells;
-      retVal.appendCell = async (n, baseUrl) => {
-          const cell = await createCell(n, baseUrl);
-          retVal.disposeCell(cell.id);
+      retVal.set = async (n) => {
+          const cell = await createCell(n, { baseUrl, importMode });
+          retVal.delete(cell.id);
           cells.set(cell.id, cell);
           return cell;
       };
-      retVal.disposeCell = async (id) => {
+      retVal.get = (id) => {
+          return cells.get(id);
+      };
+      retVal.delete = (id) => {
           const cell = cells.get(id);
           if (cell) {
-              cells.delete(id);
-              cell.dispose();
+              cell.delete();
+              return cells.delete(id);
           }
+          return false;
       };
-      retVal.dispose = () => {
-          cells.forEach(cell => cell.dispose());
+      retVal.clear = () => {
+          cells.forEach(cell => cell.delete());
           cells.clear();
       };
       retVal.write = (w) => {
-          w.files(notebook.files);
+          w.files(_files);
           cells.forEach(cell => cell.write(w));
       };
       retVal.toString = (w = new Writer()) => {
@@ -7191,12 +7234,17 @@ ${text}
       };
       return retVal;
   }
+  async function compile(notebookOrOjs, { baseUrl = ".", importMode = "precompiled" } = {}) {
+      const ojsNotebook = typeof notebookOrOjs === "string" ? ojs2notebook(notebookOrOjs) : notebookOrOjs;
+      const _cells = await Promise.all(ojsNotebook.nodes.map(n => createCell(n, { baseUrl, importMode })));
+      return notebook(ojsNotebook.files, _cells, { baseUrl, importMode });
+  }
 
   exports.compile = compile;
   exports.download = download;
+  exports.notebook = notebook;
   exports.ojs2notebook = ojs2notebook;
   exports.omd2notebook = omd2notebook;
-  exports.parseOmd = parseOmd;
 
   Object.defineProperty(exports, '__esModule', { value: true });