@hpcc-js/observablehq-compiler 1.1.4 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hpcc-js/observablehq-compiler",
-    "version": "1.1.4",
+    "version": "1.2.0",
     "description": "hpcc-js - ObservableHQ Compiler (unoffical)",
     "keywords": [
         "observablehq",
@@ -56,7 +56,7 @@
         "update": "npx --yes npm-check-updates -u -t minor"
     },
     "dependencies": {
-        "@hpcc-js/observable-shim": "^2.3.1",
+        "@hpcc-js/observable-shim": "^2.4.0",
         "node-fetch": "3.2.10",
         "yargs": "17.5.1"
     },
@@ -77,5 +77,5 @@
         "url": "https://github.com/hpcc-systems/Visualization/issues"
     },
     "homepage": "https://github.com/hpcc-systems/Visualization/tree/trunk/packages/observablehq-compiler",
-    "gitHead": "113e49eefde98196062fbf4150b20e833c4c8c19"
+    "gitHead": "e6a2073496de5b696e551bab0aa5a6ebd6207484"
 }

package/src/__package__.ts

@@ -1,3 +1,3 @@
 export const PKG_NAME = "@hpcc-js/observablehq-compiler";
-export const PKG_VERSION = "1.1.4";
-export const BUILD_VERSION = "2.104.8";
+export const PKG_VERSION = "1.2.0";
+export const BUILD_VERSION = "2.104.9";

package/src/__tests__/node.ts

@@ -99,7 +99,7 @@ describe("ojs", function () {
     await main.value("tenTimes");
 
     for (const cellID in define.cells) {
-      define.disposeCell(cellID);
+      define.delete(cellID);
       break;
     }
   });

package/src/compiler.ts

@@ -1,16 +1,27 @@
 import { ohq, splitModule } from "@hpcc-js/observable-shim";
-
 import { endsWith, join } from "@hpcc-js/util";
 import { parseCell, ParsedImportCell } from "./cst";
 import { Writer } from "./writer";
 import { encodeBacktick, fetchEx, obfuscatedImport, ojs2notebook, omd2notebook } from "./util";
 
+//  Inspector Factory  ---
+export type InspectorFactoryEx = (name: string | undefined, id: string | number) => Inspector;
+
+export interface Inspector {
+    _node?: HTMLDivElement;
+    pending();
+    fulfilled(value);
+    rejected(error);
+}
+
+//  Module  ---
+
 const isRelativePath = (path: string) => path[0] === ".";
 const fullUrl = (path: string, basePath: string) => isRelativePath(path) ? join(basePath, path) : path;
 
 interface ImportDefine {
-    (runtime: ohq.Runtime, inspector?: ohq.InspectorFactory): ohq.Module;
-    dispose: () => void;
+    (runtime: ohq.Runtime, inspector?: InspectorFactoryEx): ohq.Module;
+    delete: () => void;
     write: (w: Writer) => void;
 }
 
@@ -25,19 +36,19 @@ async function importFile(relativePath: string, baseUrl: string) {
     } else if (endsWith(relativePath, ".omd")) {
         notebook = omd2notebook(content);
     }
-    const retVal: ImportDefine = compile(notebook, baseUrl) as any;
-    retVal.dispose = () => { };
+    const retVal: ImportDefine = compile(notebook, { baseUrl }) as any;
+    retVal.delete = () => { };
     retVal.write = (w: Writer) => {
         w.import(path);
     };
     return retVal;
 }
 
-// @ts-ignore - use precompiled notebook from observable
+// Import precompiled notebook from observable  ---
 async function importCompiledNotebook(partial: string) {
     const url = `https://api.observablehq.com/${partial[0] === "@" ? partial : `d/${partial}`}.js?v=3`;
     let impMod = {
-        default: function (runtime: ohq.Runtime, inspector?: ohq.InspectorFactory): ohq.Module {
+        default: function (runtime: ohq.Runtime, inspector?: InspectorFactoryEx): ohq.Module {
             return undefined;
         } as any
     };
@@ -46,14 +57,14 @@ async function importCompiledNotebook(partial: string) {
     } catch (e) {
     }
     const retVal: ImportDefine = impMod.default;
-    retVal.dispose = () => { };
+    retVal.delete = () => { };
     retVal.write = (w: Writer) => {
         w.import(url);
     };
     return retVal;
 }
 
-// @ts-ignore - recursive notebook parsing and compiling
+// Recursive notebook parsing and compiling
 async function importNotebook(partial: string) {
     const url = `https://api.observablehq.com/document/${partial}`;
     const notebook = fetchEx(url)
@@ -64,20 +75,63 @@ async function importNotebook(partial: string) {
             console.error(e);
         });
     const retVal: ImportDefine = compile(await notebook) as any;
-    retVal.dispose = () => { };
+    retVal.delete = () => { };
     retVal.write = (w: Writer) => {
         w.import(url);
     };
     return retVal;
 }
 
-function createVariable(inspect: boolean, name?: string, inputs?: string[], definition?: any, inline = false) {
+async function createModule(node: ohq.Node, parsed: ParsedImportCell, text: string, { baseUrl, importMode }: CompileOptions) {
+    const otherModule = isRelativePath(parsed.src) ?
+        await importFile(parsed.src, baseUrl) :
+        importMode === "recursive" ?
+            await importNotebook(parsed.src) :
+            await importCompiledNotebook(parsed.src);
+
+    const importVariables: ImportVariableFunc[] = [];
+    const variables: VariableFunc[] = [];
+    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: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx) => {
+
+        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: Writer) => {
+        otherModule.write(w);
+        w.importDefine(parsed);
+    };
+    return retVal;
+}
+type ModuleFunc = Awaited<ReturnType<typeof createModule>>;
+
+//  Variable  ---
+function createVariable(node: ohq.Node, inspect: boolean, name?: string, inputs?: string[], definition?: any, inline = false) {
 
     let i: ohq.Inspector;
     let v: ohq.Variable;
 
-    const retVal = (module: ohq.Module, inspector?: ohq.InspectorFactory) => {
-        i = inspect ? inspector(name) : undefined;
+    const retVal = (module: ohq.Module, inspector?: InspectorFactoryEx) => {
+        i = inspect ? inspector(name, node.id) : undefined;
         v = module.variable(i);
         if (arguments.length > 1) {
             try {
@@ -86,9 +140,21 @@ function createVariable(inspect: boolean, name?: string, inputs?: string[], defi
                 console.error(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: any) {
+                console.error(e?.message);
+            }
+        }
         return v;
     };
-    retVal.dispose = () => {
+    retVal.delete = () => {
         try {
             i?._node?.remove();
         } catch (e) {
@@ -121,98 +187,54 @@ function createImportVariable(name?: string, alias?: string) {
         v.import(name, alias, otherModule);
     };
 
-    retVal.dispose = () => {
+    retVal.delete = () => {
         v?.delete();
     };
     return retVal;
 }
 type ImportVariableFunc = ReturnType<typeof createImportVariable>;
 
-async function createModule(parsed: ParsedImportCell, text: string, baseUrl: string) {
-    const otherModule = isRelativePath(parsed.src) ?
-        await importFile(parsed.src, baseUrl) :
-        await importCompiledNotebook(parsed.src);
-
-    const importVariables: ImportVariableFunc[] = [];
-    const variables: VariableFunc[] = [];
-    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: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory) => {
-
-        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: Writer) => {
-        otherModule.write(w);
-        w.importDefine(parsed);
-    };
-    return retVal;
-}
-type ModuleFunc = Awaited<ReturnType<typeof createModule>>;
-
-async function createCell(node: ohq.Node, baseUrl: string) {
+// Cell  ---
+async function createCell(node: ohq.Node, options: CompileOptions) {
     const modules: ModuleFunc[] = [];
     const variables: VariableFunc[] = [];
     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: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory) => {
+    const retVal = (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx) => {
         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: Writer) => {
         modules.forEach(imp => imp.write(w));
@@ -222,20 +244,24 @@ async function createCell(node: ohq.Node, baseUrl: string) {
 }
 export type CellFunc = Awaited<ReturnType<typeof createCell>>;
 
-function createFile(file: ohq.File, baseUrl: string): [string, any] {
+//  File  ---
+function createFile(file: ohq.File, options: CompileOptions): [string, any] {
     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 }];
 }
-export type FileFunc = ReturnType<typeof createFile>;
+type FileFunc = ReturnType<typeof createFile>;
 
-export async function compile(notebook: ohq.Notebook, baseUrl: string = ".") {
-
-    const files = notebook.files.map(f => createFile(f, baseUrl));
+//  Interpret  ---
+export interface CompileOptions {
+    baseUrl?: string;
+    importMode?: "recursive" | "precompiled";
+}
+export function notebook(_files: ohq.File[] = [], _cells: CellFunc[] = [], { baseUrl = ".", importMode = "precompiled" }: CompileOptions = {}) {
+    const files: FileFunc[] = _files.map(f => createFile(f, { baseUrl, importMode }));
     const fileAttachments = new Map<string, any>(files);
-    const _cells: CellFunc[] = await Promise.all(notebook.nodes.map(n => createCell(n, baseUrl)));
-    const cells = new Map<string, CellFunc>(_cells.map(c => [c.id, c]));
+    const cells = new Map<string | number, CellFunc>(_cells.map(c => [c.id, c]));
 
-    const retVal = (runtime: ohq.Runtime, inspector?: ohq.InspectorFactory): ohq.Module => {
+    const retVal = (runtime: ohq.Runtime, inspector?: InspectorFactoryEx): ohq.Module => {
         const main = runtime.module();
         main.builtin("FileAttachment", runtime.fileAttachments(name => {
             return fileAttachments.get(name) ?? { url: new URL(fullUrl(name, baseUrl)), mimeType: null };
@@ -249,25 +275,29 @@ export async function compile(notebook: ohq.Notebook, baseUrl: string = ".") {
     };
     retVal.fileAttachments = fileAttachments;
     retVal.cells = cells;
-    retVal.appendCell = async (n: ohq.Node, baseUrl) => {
-        const cell = await createCell(n, baseUrl);
-        retVal.disposeCell(cell.id);
+    retVal.set = async (n: ohq.Node): Promise<CellFunc> => {
+        const cell = await createCell(n, { baseUrl, importMode });
+        retVal.delete(cell.id);
         cells.set(cell.id, cell);
         return cell;
     };
-    retVal.disposeCell = async (id: string) => {
+    retVal.get = (id: string | number): CellFunc => {
+        return cells.get(id);
+    };
+    retVal.delete = (id: string | number): boolean => {
         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: Writer) => {
-        w.files(notebook.files);
+        w.files(_files);
         cells.forEach(cell => cell.write(w));
     };
     retVal.toString = (w = new Writer()) => {
@@ -276,4 +306,10 @@ export async function compile(notebook: ohq.Notebook, baseUrl: string = ".") {
     };
     return retVal;
 }
+
+export async function compile(notebookOrOjs: ohq.Notebook | string, { baseUrl = ".", importMode = "precompiled" }: CompileOptions = {}) {
+    const ojsNotebook = typeof notebookOrOjs === "string" ? ojs2notebook(notebookOrOjs) : notebookOrOjs;
+    const _cells: CellFunc[] = await Promise.all(ojsNotebook.nodes.map(n => createCell(n, { baseUrl, importMode })));
+    return notebook(ojsNotebook.files, _cells, { baseUrl, importMode });
+}
 export type compileFunc = Awaited<ReturnType<typeof compile>>;

package/src/index.ts

@@ -1,6 +1,6 @@
 export type { ohq } from "@hpcc-js/observable-shim";
 
 export * from "./compiler";
-export { ojs2notebook, omd2notebook, parseOmd, download } from "./util";
+export { ojs2notebook, omd2notebook, download } from "./util";
 
 import "../src/index.css";

package/src/util.ts

@@ -77,7 +77,7 @@ function createParsedOJS(ojs: string, offset: number, inlineMD: boolean): Parsed
     };
 }
 
-export function parseOmd(_: string): ParsedOJS[] {
+function splitOmd(_: string): ParsedOJS[] {
     const retVal: ParsedOJS[] = [];
     //  Load Markdown  ---
     const re = /(```(?:\s|\S)[\s\S]*?```)/g;
@@ -119,21 +119,25 @@ export function ojs2notebook(ojs: string): ohq.Notebook {
             return {
                 id: idx,
                 mode: "js",
-                value: cell
+                value: cell.text,
+                start: cell.start,
+                end: cell.end
             };
         })
     } as ohq.Notebook;
 }
 
 export function omd2notebook(omd: string): ohq.Notebook {
-    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
             };
         })
     } as ohq.Notebook;

package/types/__package__.d.ts

@@ -1,4 +1,4 @@
 export declare const PKG_NAME = "@hpcc-js/observablehq-compiler";
-export declare const PKG_VERSION = "1.1.4";
-export declare const BUILD_VERSION = "2.104.8";
+export declare const PKG_VERSION = "1.2.0";
+export declare const BUILD_VERSION = "2.104.9";
 //# sourceMappingURL=__package__.d.ts.map

package/types/compiler.d.ts

@@ -1,88 +1,157 @@
 import { ohq } from "@hpcc-js/observable-shim";
 import { Writer } from "./writer";
-declare function createCell(node: ohq.Node, baseUrl: string): Promise<{
-    (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): void;
-    id: string;
+export declare type InspectorFactoryEx = (name: string | undefined, id: string | number) => Inspector;
+export interface Inspector {
+    _node?: HTMLDivElement;
+    pending(): any;
+    fulfilled(value: any): any;
+    rejected(error: any): any;
+}
+declare function createCell(node: ohq.Node, options: CompileOptions): Promise<{
+    (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): void;
+    id: string | number;
     modules: {
-        (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Module;
+        (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): ohq.Module;
         importVariables: {
             (main: ohq.Module, otherModule: ohq.Module): void;
-            dispose(): void;
+            delete(): void;
         }[];
         variables: {
-            (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-            dispose(): void;
+            (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+            delete(): void;
             write(w: Writer): void;
         }[];
-        dispose(): void;
+        delete(): void;
         write(w: Writer): void;
     }[];
     variables: {
-        (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-        dispose(): void;
+        (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+        delete(): void;
         write(w: Writer): void;
     }[];
-    dispose(): void;
+    delete(): void;
     write(w: Writer): void;
 }>;
 export declare type CellFunc = Awaited<ReturnType<typeof createCell>>;
-declare function createFile(file: ohq.File, baseUrl: string): [string, any];
-export declare type FileFunc = ReturnType<typeof createFile>;
-export declare function compile(notebook: ohq.Notebook, baseUrl?: string): Promise<{
-    (runtime: ohq.Runtime, inspector?: ohq.InspectorFactory): ohq.Module;
+export interface CompileOptions {
+    baseUrl?: string;
+    importMode?: "recursive" | "precompiled";
+}
+export declare function notebook(_files?: ohq.File[], _cells?: CellFunc[], { baseUrl, importMode }?: CompileOptions): {
+    (runtime: ohq.Runtime, inspector?: InspectorFactoryEx): ohq.Module;
     fileAttachments: Map<string, any>;
-    cells: Map<string, {
-        (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): void;
-        id: string;
+    cells: Map<string | number, {
+        (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): void;
+        id: string | number;
         modules: {
-            (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Module;
+            (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): ohq.Module;
             importVariables: {
                 (main: ohq.Module, otherModule: ohq.Module): void;
-                dispose(): void;
+                delete(): void;
             }[];
             variables: {
-                (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-                dispose(): void;
+                (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+                delete(): void;
                 write(w: Writer): void;
             }[];
-            dispose(): void;
+            delete(): void;
             write(w: Writer): void;
         }[];
         variables: {
-            (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-            dispose(): void;
+            (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+            delete(): void;
             write(w: Writer): void;
         }[];
-        dispose(): void;
+        delete(): void;
         write(w: Writer): void;
     }>;
-    appendCell(n: ohq.Node, baseUrl: any): Promise<{
-        (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): void;
-        id: string;
+    set(n: ohq.Node): Promise<CellFunc>;
+    get(id: string | number): CellFunc;
+    delete(id: string | number): boolean;
+    clear(): void;
+    write(w: Writer): void;
+    toString(w?: Writer): string;
+};
+export declare function compile(notebookOrOjs: ohq.Notebook | string, { baseUrl, importMode }?: CompileOptions): Promise<{
+    (runtime: ohq.Runtime, inspector?: InspectorFactoryEx): ohq.Module;
+    fileAttachments: Map<string, any>;
+    cells: Map<string | number, {
+        (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): void;
+        id: string | number;
+        modules: {
+            (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): ohq.Module;
+            importVariables: {
+                (main: ohq.Module, otherModule: ohq.Module): void;
+                delete(): void;
+            }[];
+            variables: {
+                (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+                delete(): void;
+                write(w: Writer): void;
+            }[];
+            delete(): void;
+            write(w: Writer): void;
+        }[];
+        variables: {
+            (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+            delete(): void;
+            write(w: Writer): void;
+        }[];
+        delete(): void;
+        write(w: Writer): void;
+    }>;
+    set(n: ohq.Node): Promise<{
+        (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): void;
+        id: string | number;
         modules: {
-            (runtime: ohq.Runtime, main: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Module;
+            (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): ohq.Module;
             importVariables: {
                 (main: ohq.Module, otherModule: ohq.Module): void;
-                dispose(): void;
+                delete(): void;
             }[];
             variables: {
-                (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-                dispose(): void;
+                (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+                delete(): void;
                 write(w: Writer): void;
             }[];
-            dispose(): void;
+            delete(): void;
             write(w: Writer): void;
         }[];
         variables: {
-            (module: ohq.Module, inspector?: ohq.InspectorFactory): ohq.Variable;
-            dispose(): void;
+            (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+            delete(): void;
             write(w: Writer): void;
         }[];
-        dispose(): void;
+        delete(): void;
         write(w: Writer): void;
     }>;
-    disposeCell(id: string): Promise<void>;
-    dispose(): void;
+    get(id: string | number): {
+        (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): void;
+        id: string | number;
+        modules: {
+            (runtime: ohq.Runtime, main: ohq.Module, inspector?: InspectorFactoryEx): ohq.Module;
+            importVariables: {
+                (main: ohq.Module, otherModule: ohq.Module): void;
+                delete(): void;
+            }[];
+            variables: {
+                (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+                delete(): void;
+                write(w: Writer): void;
+            }[];
+            delete(): void;
+            write(w: Writer): void;
+        }[];
+        variables: {
+            (module: ohq.Module, inspector?: InspectorFactoryEx): ohq.Variable;
+            delete(): void;
+            write(w: Writer): void;
+        }[];
+        delete(): void;
+        write(w: Writer): void;
+    };
+    delete(id: string | number): boolean;
+    clear(): void;
     write(w: Writer): void;
     toString(w?: Writer): string;
 }>;

package/types/compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAe,MAAM,0BAA0B,CAAC;AAI5D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AA2KlC,iBAAe,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM;cA8B5B,IAAI,OAAO,QAAQ,IAAI,MAAM,cAAc,IAAI,gBAAgB;;;;;;;;;;;;;;;;;;;;;;aAWrE,MAAM;GAK5B;AACD,oBAAY,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC;AAE9D,iBAAS,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAGlE;AACD,oBAAY,QAAQ,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AAErD,wBAAsB,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,EAAE,OAAO,GAAE,MAAY;cAO9C,IAAI,OAAO,cAAc,IAAI,gBAAgB,GAAG,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcrD,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;oBAMN,MAAM;;aAWnB,MAAM;;GAS5B;AACD,oBAAY,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC"}
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAe,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAIlC,oBAAY,kBAAkB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,KAAK,SAAS,CAAC;AAE9F,MAAM,WAAW,SAAS;IACtB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,OAAO,QAAG;IACV,SAAS,CAAC,KAAK,KAAA,OAAE;IACjB,QAAQ,CAAC,KAAK,KAAA,OAAE;CACnB;AAuLD,iBAAe,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,cAAc;cA8BpC,IAAI,OAAO,QAAQ,IAAI,MAAM,cAAc,kBAAkB;;;;;;;;;;;;;;;;;;;;;;aAWnE,MAAM;GAK5B;AACD,oBAAY,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC;AAU9D,MAAM,WAAW,cAAc;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC;CAC5C;AACD,wBAAgB,QAAQ,CAAC,MAAM,GAAE,GAAG,CAAC,IAAI,EAAO,EAAE,MAAM,GAAE,QAAQ,EAAO,EAAE,EAAE,OAAa,EAAE,UAA0B,EAAE,GAAE,cAAmB;cAKhH,IAAI,OAAO,cAAc,kBAAkB,GAAG,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;WAc1D,QAAQ,GAAG,QAAQ,QAAQ,CAAC;YAMjC,MAAM,GAAG,MAAM,GAAG,QAAQ;eAGvB,MAAM,GAAG,MAAM,GAAG,OAAO;;aAY3B,MAAM;;EAS5B;AAED,wBAAsB,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC,QAAQ,GAAG,MAAM,EAAE,EAAE,OAAa,EAAE,UAA0B,EAAE,GAAE,cAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIrI;AACD,oBAAY,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC"}