@hpcc-js/observablehq-compiler 3.3.9 → 3.4.0

package/src/compiler.ts

@@ -1,7 +1,10 @@
+
+import { type Notebook, transpile } from "@observablehq/notebook-kit";
+import { type Definition } from "@observablehq/notebook-kit/runtime";
 import { ohq, splitModule } from "./observable-shim.ts";
 import { parseCell, ParsedImportCell } from "./cst.ts";
 import { Writer } from "./writer.ts";
-import { fixRelativeUrl, isRelativePath, encodeBacktick, fetchEx, obfuscatedImport, ojs2notebook, omd2notebook } from "./util.ts";
+import { fixRelativeUrl, isRelativePath, encodeBacktick, fetchEx, obfuscatedImport, ojs2notebook, omd2notebook, constructFunction } from "./util.ts";
 
 //  Inspector Factory  ---
 export type InspectorFactoryEx = (name: string | undefined, id: string | number) => Inspector;
@@ -314,10 +317,38 @@ export function notebook(_files: ohq.File[] = [], _cells: CellFunc[] = [], { bas
     };
     return retVal;
 }
+type NotebookFunc = ReturnType<typeof notebook>;
+
+export function compileKit(notebook: Notebook): Definition[] {
+    const retVal: Definition[] = [];
+    for (const cell of notebook.cells) {
+        const compiled = transpile(cell);
+        retVal.push({
+            id: cell.id,
+            ...compiled,
+            body: constructFunction(compiled.body)
+        });
+    }
+    return retVal;
+}
+
+export function isNotebookKit(value: any): value is Notebook {
+    return !!value && Array.isArray(value.cells);
+}
 
-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 function isOhqNotebook(value: any): value is ohq.Notebook {
+    return !!value && Array.isArray(value.nodes);
+}
+export async function compile(notebookOrOjs: Notebook): Promise<Definition[]>;
+export async function compile(notebookOrOjs: ohq.Notebook, options?: CompileOptions): Promise<NotebookFunc>;
+export async function compile(notebookOrOjs: string, options?: CompileOptions): Promise<NotebookFunc>;
+export async function compile(notebookOrOjs: Notebook | ohq.Notebook | string, { baseUrl = ".", importMode = "precompiled" }: CompileOptions = {}) {
+    if (isNotebookKit(notebookOrOjs)) {
+        return compileKit(notebookOrOjs);
+    } else if (typeof notebookOrOjs === "string") {
+        notebookOrOjs = ojs2notebook(notebookOrOjs);
+    }
+    const _cells: CellFunc[] = await Promise.all(notebookOrOjs.nodes.map(n => createCell(n, { baseUrl, importMode })));
+    return notebook(notebookOrOjs.files, _cells, { baseUrl, importMode });
 }
-export type compileFunc = Awaited<ReturnType<typeof compile>>;
+export type CompileFunc = Awaited<ReturnType<typeof compile>>;

package/src/index.node.ts

@@ -0,0 +1,7 @@
+import { JSDOM } from "jsdom";
+
+const { window } = new JSDOM();
+globalThis.document = window.document;
+globalThis.DOMParser = window.DOMParser;
+
+export * from "./index.ts";

package/src/index.ts

@@ -1,7 +1,7 @@
 export type { ohq } from "./observable-shim.ts";
 
 export * from "./compiler.ts";
-export { ojs2notebook, omd2notebook, download } from "./util.ts";
+export { ojs2notebook, omd2notebook, omd2notebookKit, ojs2notebookKit, download, html2notebook, notebook2html } from "./util.ts";
 export * from "./writer.ts";
 
 import "../src/index.css";

package/src/util.ts

@@ -1,18 +1,57 @@
+import { type Notebook, type Cell, toCell, toNotebook, parseJavaScript, serialize, deserialize } from "@observablehq/notebook-kit";
+
 import type { ohq } from "./observable-shim.ts";
 import { parseCell, splitModule } from "./observable-shim.ts";
 
-const FuncTypes = {
-    functionType: Object.getPrototypeOf(function () { }).constructor,
-    asyncFunctionType: Object.getPrototypeOf(async function () { }).constructor,
-    generatorFunctionType: Object.getPrototypeOf(function* () { }).constructor,
-    asyncGeneratorFunctionType: Object.getPrototypeOf(async function* () { }).constructor
+// Shared function constructor utilities to avoid duplication between util modules.
+
+export type RegularFunction = (...args: any[]) => any;
+interface RegularFunctionConstructor {
+    new(...args: string[]): RegularFunction;
+    (...args: string[]): RegularFunction;
+    readonly prototype: RegularFunction;
+}
+
+export type AsyncFunction = (...args: any[]) => Promise<any>;
+interface AsyncFunctionConstructor {
+    new(...args: string[]): AsyncFunction;
+    (...args: string[]): AsyncFunction;
+    readonly prototype: AsyncFunction;
+}
+
+export type GeneratorFunction = (...args: any[]) => Generator<any, any, any>;
+interface GeneratorFunctionConstructor {
+    new(...args: string[]): GeneratorFunction;
+    (...args: string[]): GeneratorFunction;
+    readonly prototype: GeneratorFunction;
+}
+
+export type AsyncGeneratorFunction = (...args: any[]) => AsyncGenerator<any, any, any>;
+interface AsyncGeneratorFunctionConstructor {
+    new(...args: string[]): AsyncGeneratorFunction;
+    (...args: string[]): AsyncGeneratorFunction;
+    readonly prototype: AsyncGeneratorFunction;
+}
+
+export type AnyFunction = RegularFunction | AsyncFunction | GeneratorFunction | AsyncGeneratorFunction;
+
+export const FunctionConstructors: {
+    regular: RegularFunctionConstructor;
+    async: AsyncFunctionConstructor;
+    generator: GeneratorFunctionConstructor;
+    asyncGenerator: AsyncGeneratorFunctionConstructor;
+} = {
+    regular: Object.getPrototypeOf(function () { }).constructor as RegularFunctionConstructor,
+    async: Object.getPrototypeOf(async function () { }).constructor as AsyncFunctionConstructor,
+    generator: Object.getPrototypeOf(function* () { }).constructor as GeneratorFunctionConstructor,
+    asyncGenerator: Object.getPrototypeOf(async function* () { }).constructor as AsyncGeneratorFunctionConstructor,
 };
 
 function funcType(async: boolean = false, generator: boolean = false) {
-    if (!async && !generator) return FuncTypes.functionType;
-    if (async && !generator) return FuncTypes.asyncFunctionType;
-    if (!async && generator) return FuncTypes.generatorFunctionType;
-    return FuncTypes.asyncGeneratorFunctionType;
+    if (!async && !generator) return FunctionConstructors.regular;
+    if (async && !generator) return FunctionConstructors.async;
+    if (!async && generator) return FunctionConstructors.generator;
+    return FunctionConstructors.asyncGenerator;
 }
 
 interface Ref {
@@ -56,8 +95,9 @@ export const fixRelativeUrl = (path: string, basePath: string) => {
 };
 
 //  Hide "import" from bundlers as they have a habit of replacing "import" with "require"
+const obfuscatedImportFunction = new FunctionConstructors.async("url", "return import(url)");
 export async function obfuscatedImport(url: string) {
-    return new FuncTypes.asyncFunctionType("url", "return import(url)")(url);
+    return obfuscatedImportFunction(url);
 }
 
 interface ParsedOJS {
@@ -141,6 +181,17 @@ export function ojs2notebook(ojs: string): ohq.Notebook {
     } as ohq.Notebook;
 }
 
+export function ojs2notebookKit(ojs: string): Notebook {
+    const cells: Cell[] = splitModule(ojs).map((cell, idx) => {
+        return toCell({
+            id: idx,
+            mode: "ojs",
+            value: cell.text
+        });
+    });
+    return toNotebook({ cells });
+}
+
 export function omd2notebook(omd: string): ohq.Notebook {
     const cells = splitOmd(omd);
     return {
@@ -157,6 +208,28 @@ export function omd2notebook(omd: string): ohq.Notebook {
     } as ohq.Notebook;
 }
 
+export function omd2notebookKit(omd: string): Notebook {
+    const cells: Cell[] = [];
+    splitOmd(omd).forEach((cell) => {
+        if (!cell.inlineMD) {
+            splitModule(cell.ojs).forEach((subCell) => {
+                cells.push(toCell({
+                    id: cells.length + 1,
+                    mode: "ojs",
+                    value: subCell.text
+                }));
+            });
+        } else {
+            cells.push(toCell({
+                id: cells.length + 1,
+                mode: "md",
+                value: cell.ojs
+            }));
+        }
+    });
+    return toNotebook({ cells });
+}
+
 export function fetchEx(url: string, proxyPrefix = "https://api.codetabs.com/v1/proxy/?quest=", proxyPostfix = "") {
     const matches = url.match(/^(?:https?:\/\/)?(?:[^@\n]+@)?(?:www\.)?([^:\/\n?]+)/img);
     if (!matches || matches.length === 0) {
@@ -176,4 +249,40 @@ export function download(impUrl: string, proxyPrefix?: string, proxyPostfix?: st
     return fetchEx(impUrl.replace(`https://observablehq.com/${isShared ? "d/" : ""}`, "https://api.observablehq.com/document/"), proxyPrefix, proxyPostfix)
         .then(r => r.json())
         ;
-}
+}
+
+function _constructFunction(body, bodyStr: string) {
+    if (body.type !== "FunctionExpression" && body.type !== "FunctionDeclaration" && body.type !== "ArrowFunctionExpression") {
+        throw new Error(`Unsupported function type: ${body.type}`);
+    }
+    const func = body.async && body.generator ?
+        FunctionConstructors.asyncGenerator :
+        body.async ?
+            FunctionConstructors.async :
+            body.generator ?
+                FunctionConstructors.generator :
+                FunctionConstructors.regular;
+
+    const params = body.params?.map((param) => bodyStr.slice(param.start, param.end)).join(", ") ?? "";
+    const isBlock = body.body.type === "BlockStatement";
+    const { start, end } = body.body;
+    const inner = isBlock
+        ? bodyStr.slice(start + 1, end - 1)
+        : `return ${bodyStr.slice(start, end)}`;
+    return func(params, inner);
+}
+
+export function constructFunction(bodyStr: string) {
+    const { body } = parseJavaScript(bodyStr);
+    if (body.type === "Program") {
+        if (body.body.length !== 1) {
+            throw new Error(`Expected a single function, but found ${body.body.length} statements`);
+        }
+        return _constructFunction(body.body[0], bodyStr);
+    }
+    return _constructFunction(body, bodyStr);
+}
+
+export const html2notebook = (html: string): Notebook => deserialize(html);
+export const notebook2html = (notebook: Notebook): string => serialize(notebook);
+

package/types/compiler.d.ts

@@ -1,3 +1,5 @@
+import { type Notebook } from "@observablehq/notebook-kit";
+import { type Definition } from "@observablehq/notebook-kit/runtime";
 import { ohq } from "./observable-shim.ts";
 import { Writer } from "./writer.ts";
 export type InspectorFactoryEx = (name: string | undefined, id: string | number) => Inspector;
@@ -72,40 +74,12 @@ export declare function notebook(_files?: ohq.File[], _cells?: CellFunc[], { bas
     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<CellFunc>;
-    get(id: string | number): CellFunc | undefined;
-    delete(id: string | number): boolean;
-    clear(): void;
-    write(w: Writer): void;
-    toString(w?: Writer): string;
-}>;
-export type compileFunc = Awaited<ReturnType<typeof compile>>;
+type NotebookFunc = ReturnType<typeof notebook>;
+export declare function compileKit(notebook: Notebook): Definition[];
+export declare function isNotebookKit(value: any): value is Notebook;
+export declare function isOhqNotebook(value: any): value is ohq.Notebook;
+export declare function compile(notebookOrOjs: Notebook): Promise<Definition[]>;
+export declare function compile(notebookOrOjs: ohq.Notebook, options?: CompileOptions): Promise<NotebookFunc>;
+export declare function compile(notebookOrOjs: string, options?: CompileOptions): Promise<NotebookFunc>;
+export type CompileFunc = Awaited<ReturnType<typeof compile>>;
 export {};

package/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { ohq } from "./observable-shim.ts";
 export * from "./compiler.ts";
-export { ojs2notebook, omd2notebook, download } from "./util.ts";
+export { ojs2notebook, omd2notebook, omd2notebookKit, ojs2notebookKit, download, html2notebook, notebook2html } from "./util.ts";
 export * from "./writer.ts";
 import "../src/index.css";

package/types/util.d.ts

@@ -1,4 +1,36 @@
+import { type Notebook } from "@observablehq/notebook-kit";
 import type { ohq } from "./observable-shim.ts";
+export type RegularFunction = (...args: any[]) => any;
+interface RegularFunctionConstructor {
+    new (...args: string[]): RegularFunction;
+    (...args: string[]): RegularFunction;
+    readonly prototype: RegularFunction;
+}
+export type AsyncFunction = (...args: any[]) => Promise<any>;
+interface AsyncFunctionConstructor {
+    new (...args: string[]): AsyncFunction;
+    (...args: string[]): AsyncFunction;
+    readonly prototype: AsyncFunction;
+}
+export type GeneratorFunction = (...args: any[]) => Generator<any, any, any>;
+interface GeneratorFunctionConstructor {
+    new (...args: string[]): GeneratorFunction;
+    (...args: string[]): GeneratorFunction;
+    readonly prototype: GeneratorFunction;
+}
+export type AsyncGeneratorFunction = (...args: any[]) => AsyncGenerator<any, any, any>;
+interface AsyncGeneratorFunctionConstructor {
+    new (...args: string[]): AsyncGeneratorFunction;
+    (...args: string[]): AsyncGeneratorFunction;
+    readonly prototype: AsyncGeneratorFunction;
+}
+export type AnyFunction = RegularFunction | AsyncFunction | GeneratorFunction | AsyncGeneratorFunction;
+export declare const FunctionConstructors: {
+    regular: RegularFunctionConstructor;
+    async: AsyncFunctionConstructor;
+    generator: GeneratorFunctionConstructor;
+    asyncGenerator: AsyncGeneratorFunctionConstructor;
+};
 interface Ref {
     start: number;
     end: number;
@@ -9,7 +41,7 @@ export interface Refs {
     args: string[];
     patches: Ref[];
 }
-export declare function createFunction(refs: Refs, async?: boolean, generator?: boolean, blockStatement?: boolean, body?: string): any;
+export declare function createFunction(refs: Refs, async?: boolean, generator?: boolean, blockStatement?: boolean, body?: string): RegularFunction | undefined;
 export declare const isRelativePath: (path: string) => boolean;
 export declare const fixRelativeUrl: (path: string, basePath: string) => string;
 export declare function obfuscatedImport(url: string): Promise<any>;
@@ -23,7 +55,12 @@ interface ParsedOJS {
 export declare function encodeBacktick(str: string): string;
 export declare function notebook2ojs(_: string): ParsedOJS[];
 export declare function ojs2notebook(ojs: string): ohq.Notebook;
+export declare function ojs2notebookKit(ojs: string): Notebook;
 export declare function omd2notebook(omd: string): ohq.Notebook;
+export declare function omd2notebookKit(omd: string): Notebook;
 export declare function fetchEx(url: string, proxyPrefix?: string, proxyPostfix?: string): Promise<Response>;
 export declare function download(impUrl: string, proxyPrefix?: string, proxyPostfix?: string): Promise<ohq.Notebook>;
+export declare function constructFunction(bodyStr: string): RegularFunction;
+export declare const html2notebook: (html: string) => Notebook;
+export declare const notebook2html: (notebook: Notebook) => string;
 export {};