@hpcc-js/observablehq-compiler 3.7.5 → 3.7.8

package/src/cst.ts

@@ -1,181 +1,181 @@
-import { ancestor, parseCell as ohqParseCell, Cell, Node, walk, AncestorVisitors } from "./observable-shim.ts";
-import { fixRelativeUrl, createFunction, Refs } from "./kit/index.ts";
-
-function calcRefs(cellAst: Cell, cellStr: string): Refs {
-    if (cellAst.references === undefined) return { inputs: [], args: [], patches: [] };
-
-    const dedup: { [id: string]: boolean } = {};
-    cellAst.references.forEach((r: any) => dedup[cellStr.substring(r.start, r.end)] = true);
-    const retVal: Refs = {
-        inputs: Object.keys(dedup),
-        args: Object.keys(dedup).map(r => r.split(" ").join("_")),
-        patches: []
-    };
-    const pushPatch = (node: Node, newText: string) => retVal.patches.push({ start: node.start - (cellAst.body?.start ?? 0), end: node.end - (cellAst.body?.start ?? 0), newText });
-    if (cellAst.body) {
-        ancestor(cellAst.body, {
-            Identifier(node) {
-                const value = cellStr.substring(node.start, node.end);
-                if (dedup[value]) {
-                }
-            },
-            MutableExpression(node: Node) {
-                const value = cellStr.substring(node.start, node.end);
-                const newText = value.split(" ").join("_") + ".value";
-                pushPatch(node, newText);
-            },
-            ViewExpression(node: Node) {
-                const value = cellStr.substring(node.start, node.end);
-                const newText = value.split(" ").join("_");
-                pushPatch(node, newText);
-            },
-            ThisExpression(node: Node, ancestors: Node[]) {
-                const value = cellStr.substring(node.start, node.end);
-                if (value === "this" && !ancestors.find(n => n.type === "FunctionExpression")) {
-                    pushPatch(node, "((this === globalThis || this === globalThis.window)? undefined : this?.valueOf())");
-                }
-            }
-        } as AncestorVisitors<any>, walk);
-    }
-    return retVal;
-}
-
-export interface ParsedCell {
-    type: "import" | "viewof" | "mutable" | "variable" | "identifier"
-}
-
-export interface ParsedImportCell extends ParsedCell {
-    type: "import"
-    src: string;
-    specifiers: { view: boolean, name: string, alias?: string }[];
-    injections: { name: string, alias: string }[];
-}
-
-function parseImportDeclaration(cellAst: any): ParsedImportCell {
-    return {
-        type: "import",
-        src: cellAst.body.source.value,
-        specifiers: cellAst.body.specifiers?.map((spec: any) => {
-            return {
-                view: spec.view,
-                name: spec.imported.name,
-                alias: (spec.local?.name && spec.imported.name !== spec.local.name) ? spec.local.name : spec.imported.name
-            };
-        }) ?? [],
-        injections: cellAst.body.injections?.map((inj: any) => {
-            return {
-                name: inj.imported.name,
-                alias: inj.local?.name ?? inj.imported.name
-            };
-        }) ?? [],
-    };
-}
-
-export interface ParsedVariable extends ParsedCell {
-    type: "variable"
-    id?: string,
-    inputs: string[],
-    func: any,
-}
-
-export interface ParsedViewCell extends ParsedCell {
-    type: "viewof",
-    variable: ParsedVariable;
-    variableValue: ParsedVariable;
-}
-
-function parseViewExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedViewCell {
-    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
-    return {
-        type: "viewof",
-        variable: {
-            type: "variable",
-            id,
-            inputs: refs.inputs,
-            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-        },
-        variableValue: {
-            type: "variable",
-            id: cellAst?.id?.id?.name,
-            inputs: ["Generators", id],
-            func: (G: any, _: any) => G.input(_)
-        }
-    };
-}
-
-interface ParsedMutableCell extends ParsedCell {
-    type: "mutable",
-    initial: ParsedVariable;
-    variable: ParsedVariable;
-    variableValue: ParsedVariable;
-}
-
-function parseMutableExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedMutableCell {
-    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
-    const initialValueId = cellAst?.id?.id?.name;
-    const initialId = `initial ${initialValueId}`;
-    return {
-        type: "mutable",
-        initial: {
-            type: "variable",
-            id: initialId,
-            inputs: refs.inputs,
-            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-        },
-        variable: {
-            type: "variable",
-            id,
-            inputs: ["Mutable", initialId],
-            func: (M: any, _: any) => new M(_)
-        },
-        variableValue: {
-            type: "variable",
-            id: initialValueId,
-            inputs: [id],
-            func: (_: any) => _.generator
-        }
-    };
-}
-
-interface ParsedVariableCell extends ParsedCell {
-    type: "variable",
-    id: string,
-    inputs: string[],
-    func: any,
-}
-
-function parseVariableExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedVariableCell {
-    return {
-        type: "variable",
-        id: cellAst.id && cellStr.substring(cellAst.id?.start, cellAst.id?.end),
-        inputs: refs.inputs,
-        func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
-    };
-}
-
-export function parseCell(cellStr: string, baseUrl: string): ParsedImportCell | ParsedViewCell | ParsedMutableCell | ParsedVariableCell {
-    const cellAst = ohqParseCell(cellStr);
-    let bodyStr = cellAst.body && cellStr.substring(cellAst.body.start, cellAst.body.end);
-    switch ((cellAst.body)?.type) {
-        case "ImportDeclaration":
-            return parseImportDeclaration(cellAst);
-        case "ImportExpression":
-            switch (cellAst.body.source.type) {
-                case "Literal":
-                    bodyStr = `import("${fixRelativeUrl("" + cellAst.body.source.value, baseUrl)}")`;
-                    break;
-                default:
-                    console.error("Unexpected import value");
-            }
-    }
-    const refs = calcRefs(cellAst, cellStr);
-    switch (cellAst.id?.type) {
-        case "ViewExpression":
-            return parseViewExpression(cellStr, cellAst, refs, bodyStr);
-        case "MutableExpression":
-            return parseMutableExpression(cellStr, cellAst, refs, bodyStr);
-        default:
-            return parseVariableExpression(cellStr, cellAst, refs, bodyStr);
-    }
-}
-
+import { ancestor, parseCell as ohqParseCell, Cell, Node, walk, AncestorVisitors } from "./observable-shim.ts";
+import { fixRelativeUrl, createFunction, Refs } from "./kit/index.ts";
+
+function calcRefs(cellAst: Cell, cellStr: string): Refs {
+    if (cellAst.references === undefined) return { inputs: [], args: [], patches: [] };
+
+    const dedup: { [id: string]: boolean } = {};
+    cellAst.references.forEach((r: any) => dedup[cellStr.substring(r.start, r.end)] = true);
+    const retVal: Refs = {
+        inputs: Object.keys(dedup),
+        args: Object.keys(dedup).map(r => r.split(" ").join("_")),
+        patches: []
+    };
+    const pushPatch = (node: Node, newText: string) => retVal.patches.push({ start: node.start - (cellAst.body?.start ?? 0), end: node.end - (cellAst.body?.start ?? 0), newText });
+    if (cellAst.body) {
+        ancestor(cellAst.body, {
+            Identifier(node) {
+                const value = cellStr.substring(node.start, node.end);
+                if (dedup[value]) {
+                }
+            },
+            MutableExpression(node: Node) {
+                const value = cellStr.substring(node.start, node.end);
+                const newText = value.split(" ").join("_") + ".value";
+                pushPatch(node, newText);
+            },
+            ViewExpression(node: Node) {
+                const value = cellStr.substring(node.start, node.end);
+                const newText = value.split(" ").join("_");
+                pushPatch(node, newText);
+            },
+            ThisExpression(node: Node, ancestors: Node[]) {
+                const value = cellStr.substring(node.start, node.end);
+                if (value === "this" && !ancestors.find(n => n.type === "FunctionExpression")) {
+                    pushPatch(node, "((this === globalThis || this === globalThis.window)? undefined : this?.valueOf())");
+                }
+            }
+        } as AncestorVisitors<any>, walk);
+    }
+    return retVal;
+}
+
+export interface ParsedCell {
+    type: "import" | "viewof" | "mutable" | "variable" | "identifier"
+}
+
+export interface ParsedImportCell extends ParsedCell {
+    type: "import"
+    src: string;
+    specifiers: { view: boolean, name: string, alias?: string }[];
+    injections: { name: string, alias: string }[];
+}
+
+function parseImportDeclaration(cellAst: any): ParsedImportCell {
+    return {
+        type: "import",
+        src: cellAst.body.source.value,
+        specifiers: cellAst.body.specifiers?.map((spec: any) => {
+            return {
+                view: spec.view,
+                name: spec.imported.name,
+                alias: (spec.local?.name && spec.imported.name !== spec.local.name) ? spec.local.name : spec.imported.name
+            };
+        }) ?? [],
+        injections: cellAst.body.injections?.map((inj: any) => {
+            return {
+                name: inj.imported.name,
+                alias: inj.local?.name ?? inj.imported.name
+            };
+        }) ?? [],
+    };
+}
+
+export interface ParsedVariable extends ParsedCell {
+    type: "variable"
+    id?: string,
+    inputs: string[],
+    func: any,
+}
+
+export interface ParsedViewCell extends ParsedCell {
+    type: "viewof",
+    variable: ParsedVariable;
+    variableValue: ParsedVariable;
+}
+
+function parseViewExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedViewCell {
+    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
+    return {
+        type: "viewof",
+        variable: {
+            type: "variable",
+            id,
+            inputs: refs.inputs,
+            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+        },
+        variableValue: {
+            type: "variable",
+            id: cellAst?.id?.id?.name,
+            inputs: ["Generators", id],
+            func: (G: any, _: any) => G.input(_)
+        }
+    };
+}
+
+interface ParsedMutableCell extends ParsedCell {
+    type: "mutable",
+    initial: ParsedVariable;
+    variable: ParsedVariable;
+    variableValue: ParsedVariable;
+}
+
+function parseMutableExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedMutableCell {
+    const id = cellAst.id && cellStr.substring(cellAst.id.start, cellAst.id.end);
+    const initialValueId = cellAst?.id?.id?.name;
+    const initialId = `initial ${initialValueId}`;
+    return {
+        type: "mutable",
+        initial: {
+            type: "variable",
+            id: initialId,
+            inputs: refs.inputs,
+            func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+        },
+        variable: {
+            type: "variable",
+            id,
+            inputs: ["Mutable", initialId],
+            func: (M: any, _: any) => new M(_)
+        },
+        variableValue: {
+            type: "variable",
+            id: initialValueId,
+            inputs: [id],
+            func: (_: any) => _.generator
+        }
+    };
+}
+
+interface ParsedVariableCell extends ParsedCell {
+    type: "variable",
+    id: string,
+    inputs: string[],
+    func: any,
+}
+
+function parseVariableExpression(cellStr: string, cellAst: any, refs: Refs, bodyStr?: string): ParsedVariableCell {
+    return {
+        type: "variable",
+        id: cellAst.id && cellStr.substring(cellAst.id?.start, cellAst.id?.end),
+        inputs: refs.inputs,
+        func: createFunction(refs, cellAst.async, cellAst.generator, cellAst.body.type === "BlockStatement", bodyStr)
+    };
+}
+
+export function parseCell(cellStr: string, baseUrl: string): ParsedImportCell | ParsedViewCell | ParsedMutableCell | ParsedVariableCell {
+    const cellAst = ohqParseCell(cellStr);
+    let bodyStr = cellAst.body && cellStr.substring(cellAst.body.start, cellAst.body.end);
+    switch ((cellAst.body)?.type) {
+        case "ImportDeclaration":
+            return parseImportDeclaration(cellAst);
+        case "ImportExpression":
+            switch (cellAst.body.source.type) {
+                case "Literal":
+                    bodyStr = `import("${fixRelativeUrl("" + cellAst.body.source.value, baseUrl)}")`;
+                    break;
+                default:
+                    console.error("Unexpected import value");
+            }
+    }
+    const refs = calcRefs(cellAst, cellStr);
+    switch (cellAst.id?.type) {
+        case "ViewExpression":
+            return parseViewExpression(cellStr, cellAst, refs, bodyStr);
+        case "MutableExpression":
+            return parseMutableExpression(cellStr, cellAst, refs, bodyStr);
+        default:
+            return parseVariableExpression(cellStr, cellAst, refs, bodyStr);
+    }
+}
+

package/src/index.node.ts

@@ -1,7 +1,7 @@
-import { JSDOM } from "jsdom";
-
-const { window } = new JSDOM();
-globalThis.document = window.document;
-globalThis.DOMParser = window.DOMParser;
-
-export * from "./index.ts";
+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,6 +1,6 @@
-export type { ohq } from "./observable-shim.ts";
-
-export * from "./compiler.ts";
-export { ojs2notebook, omd2notebook, omd2notebookKit, ojs2notebookKit, download } from "./util.ts";
-export * from "./kit/index.ts";
-export * from "./writer.ts";
+export type { ohq } from "./observable-shim.ts";
+
+export * from "./compiler.ts";
+export { ojs2notebook, omd2notebook, omd2notebookKit, ojs2notebookKit, download } from "./util.ts";
+export * from "./kit/index.ts";
+export * from "./writer.ts";

package/src/kit/compiler.ts

@@ -1,60 +1,60 @@
-
-import { type Notebook, type Cell, transpile } from "@observablehq/notebook-kit";
-import { type Definition } from "@observablehq/notebook-kit/runtime";
-import { constructFunction } from "./util.ts";
-
-export { Notebook, Cell };
-
-export interface CompileCellOptions {
-    inline?: boolean;
-    resolveLocalImports?: boolean;
-    includePinned?: boolean;
-}
-
-export function compileCell(cell: Cell, { inline = true, resolveLocalImports = false, includePinned = true }: CompileCellOptions = {}): Definition[] {
-    const retVal: Definition[] = [];
-    const sourceIDOffset = 1000000;
-    try {
-        const compiled = transpile(cell, { resolveLocalImports });
-        retVal.push({
-            id: cell.id,
-            ...compiled,
-            body: inline ? constructFunction(compiled.body, `cell_${cell.id}`) : compiled.body,
-        });
-        if (includePinned && cell.pinned) {
-            const compiled = transpile({
-                ...cell,
-                mode: "md",
-                value: `\
-\`\`\`${cell.mode}
-${cell.value}
-\`\`\``
-            });
-            retVal.push({
-                id: sourceIDOffset + cell.id,
-                ...compiled,
-                body: inline ? constructFunction(compiled.body, `cell_${sourceIDOffset + cell.id}`) : compiled.body,
-            });
-        }
-    } catch (error) {
-        console.error(`Error compiling cell ${cell.id}:`, error);
-    }
-    return retVal;
-}
-
-export function compileNotebook(notebook: Notebook, { inline = true, resolveLocalImports = false, includePinned = true }: CompileCellOptions = {}): Definition[] {
-    const retVal: Definition[] = [];
-    for (const cell of notebook.cells) {
-        const cellDefs = compileCell(cell, { inline, resolveLocalImports, includePinned });
-        retVal.push(...cellDefs);
-    }
-    return retVal;
-}
-
-export function resetCellIDs(notebook: Notebook, start: number = 0, increment: number = 1): Notebook {
-    for (const cell of notebook.cells) {
-        cell.id = start;
-        start += increment;
-    }
-    return notebook;
-}
+
+import { type Notebook, type Cell, transpile } from "@observablehq/notebook-kit";
+import { type Definition } from "@observablehq/notebook-kit/runtime";
+import { constructFunction } from "./util.ts";
+
+export { Notebook, Cell };
+
+export interface CompileCellOptions {
+    inline?: boolean;
+    resolveLocalImports?: boolean;
+    includePinned?: boolean;
+}
+
+export function compileCell(cell: Cell, { inline = true, resolveLocalImports = false, includePinned = true }: CompileCellOptions = {}): Definition[] {
+    const retVal: Definition[] = [];
+    const sourceIDOffset = 1000000;
+    try {
+        const compiled = transpile(cell, { resolveLocalImports });
+        retVal.push({
+            id: cell.id,
+            ...compiled,
+            body: inline ? constructFunction(compiled.body, `cell_${cell.id}`) : compiled.body,
+        });
+        if (includePinned && cell.pinned) {
+            const compiled = transpile({
+                ...cell,
+                mode: "md",
+                value: `\
+\`\`\`${cell.mode}
+${cell.value}
+\`\`\``
+            });
+            retVal.push({
+                id: sourceIDOffset + cell.id,
+                ...compiled,
+                body: inline ? constructFunction(compiled.body, `cell_${sourceIDOffset + cell.id}`) : compiled.body,
+            });
+        }
+    } catch (error) {
+        console.error(`Error compiling cell ${cell.id}:`, error);
+    }
+    return retVal;
+}
+
+export function compileNotebook(notebook: Notebook, { inline = true, resolveLocalImports = false, includePinned = true }: CompileCellOptions = {}): Definition[] {
+    const retVal: Definition[] = [];
+    for (const cell of notebook.cells) {
+        const cellDefs = compileCell(cell, { inline, resolveLocalImports, includePinned });
+        retVal.push(...cellDefs);
+    }
+    return retVal;
+}
+
+export function resetCellIDs(notebook: Notebook, start: number = 0, increment: number = 1): Notebook {
+    for (const cell of notebook.cells) {
+        cell.id = start;
+        start += increment;
+    }
+    return notebook;
+}

package/src/kit/index.ts

@@ -1,2 +1,2 @@
-export * from "./compiler.ts";
-export * from "./util.ts";
+export * from "./compiler.ts";
+export * from "./util.ts";