@observablehq/notebook-kit 1.4.0-rc.1 → 1.4.1

package/dist/package.json

@@ -5,7 +5,7 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "1.4.0-rc.1",
+    "version": "1.4.1",
     "type": "module",
     "scripts": {
         "test": "vitest",

package/dist/src/interpreters/index.js

@@ -9,7 +9,7 @@ export async function getInterpreterCachePath(sourcePath, interpreter, format, i
 export function getInterpreterCommand(interpreter) {
     switch (interpreter) {
         case "node":
-            return ["node", ["--input-type=module", "--permission", "--allow-fs-read=."]];
+            return ["node", ["--input-type=module-typescript", "--permission", "--allow-fs-read=."]];
         case "python":
             return ["python3", []];
         default:

package/dist/src/javascript/transpile.js

@@ -1,4 +1,3 @@
-import { ScriptTarget, transpile as transpileTypeScript } from "typescript";
 import { toCell } from "../lib/notebook.js";
 import { rewriteFileExpressions } from "./files.js";
 import { hasImportDeclaration } from "./imports.js";
@@ -7,6 +6,7 @@ import { transpileObservable } from "./observable.js";
 import { parseJavaScript } from "./parse.js";
 import { Sourcemap } from "./sourcemap.js";
 import { transpileTemplate } from "./template.js";
+import { transpileTypeScript } from "./typescript.js";
 export function transpile(input, mode, options) {
     let cell;
     if (typeof input === "string") {
@@ -20,7 +20,7 @@ export function transpile(input, mode, options) {
         input = cell.value;
     }
     const transpiled = mode === "ts"
-        ? transpileJavaScript(transpileTypeScript(input, { target: ScriptTarget.ESNext }), options)
+        ? transpileJavaScript(transpileTypeScript(input), options)
         : mode === "ojs"
             ? transpileObservable(input, options)
             : mode !== "js"

package/dist/src/javascript/typescript.d.ts

@@ -0,0 +1 @@
+export declare function transpileTypeScript(input: string): string;

package/dist/src/javascript/typescript.js

@@ -0,0 +1,112 @@
+import { tokenizer as Tokenizer, tokTypes } from "acorn";
+import { ModuleKind, ScriptTarget, transpile } from "typescript";
+import { createProgram, createSourceFile } from "typescript";
+import { isClassExpression, isFunctionExpression, isParenthesizedExpression } from "typescript";
+import { isExpressionStatement } from "typescript";
+const tokenizerOptions = {
+    ecmaVersion: "latest"
+};
+const compilerOptions = {
+    target: ScriptTarget.ESNext,
+    module: ModuleKind.Preserve,
+    verbatimModuleSyntax: true
+};
+export function transpileTypeScript(input) {
+    const expr = maybeExpression(input);
+    if (expr)
+        return trimTrailingSemicolon(transpile(expr, compilerOptions));
+    parseTypeScript(input); // enforce valid syntax
+    return transpile(input, compilerOptions);
+}
+/** If the given is an expression (not a statement), returns it with parens. */
+function maybeExpression(input) {
+    if (!hasMatchedParens(input))
+        return; // disallow funny business
+    const expr = withParens(input);
+    if (!isSolitaryExpression(expr))
+        return;
+    return expr;
+}
+/** Parses the specified TypeScript input, returning the AST or throwing a SyntaxError. */
+function parseTypeScript(input) {
+    const file = createSourceFile("input.ts", input, compilerOptions.target);
+    const program = createProgram(["input.ts"], compilerOptions, {
+        getSourceFile: (path) => (path === "input.ts" ? file : undefined),
+        getDefaultLibFileName: () => "lib.d.ts",
+        writeFile: () => { },
+        getCurrentDirectory: () => "/",
+        getDirectories: () => [],
+        getCanonicalFileName: (path) => path,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+        fileExists: (path) => path === "input.ts",
+        readFile: (path) => (path === "input.ts" ? input : undefined)
+    });
+    const diagnostics = program.getSyntacticDiagnostics(file);
+    if (diagnostics.length > 0) {
+        const [diagnostic] = diagnostics;
+        throw new SyntaxError(String(diagnostic.messageText));
+    }
+    return file;
+}
+/** Returns true if the specified input is exactly one parenthesized expression statement. */
+function isSolitaryExpression(input) {
+    let file;
+    try {
+        file = parseTypeScript(input);
+    }
+    catch {
+        return false;
+    }
+    if (file.statements.length !== 1)
+        return false;
+    const statement = file.statements[0];
+    if (!isExpressionStatement(statement))
+        return false;
+    const expression = statement.expression;
+    if (!isParenthesizedExpression(expression))
+        return false;
+    const subexpression = expression.expression;
+    if (isClassExpression(subexpression) && subexpression.name)
+        return false;
+    if (isFunctionExpression(subexpression) && subexpression.name)
+        return false;
+    return true;
+}
+function* tokenize(input) {
+    const tokenizer = Tokenizer(input, tokenizerOptions);
+    while (true) {
+        const t = tokenizer.getToken();
+        if (t.type === tokTypes.eof)
+            break;
+        yield t;
+    }
+}
+/** Returns true if the specified input has matched parens. */
+function hasMatchedParens(input) {
+    let depth = 0;
+    for (const t of tokenize(input)) {
+        if (t.type === tokTypes.parenL)
+            ++depth;
+        else if (t.type === tokTypes.parenR && --depth < 0)
+            return false;
+    }
+    return depth === 0;
+}
+/** Wraps the specified input with parentheses. */
+function withParens(input) {
+    let start;
+    let end;
+    for (const t of tokenize(input)) {
+        start ?? (start = t);
+        end = t;
+    }
+    return `(${input.slice(start?.start, end?.end)})`;
+}
+/** Removes a trailing semicolon, if present. */
+function trimTrailingSemicolon(input) {
+    let end;
+    for (const t of tokenize(input))
+        end = t;
+    return end?.type === tokTypes.semi ? input.slice(0, end.start) : input;
+}

package/dist/src/javascript/typescript.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/javascript/typescript.test.js

@@ -0,0 +1,34 @@
+import { assert, expect, it } from "vitest";
+import { transpileTypeScript } from "./typescript.js";
+it("transpiles TypeScript expressions", () => {
+    expect(transpileTypeScript("1 + 2")).toMatchSnapshot();
+    expect(transpileTypeScript("1, 2")).toMatchSnapshot();
+    expect(transpileTypeScript("1, 2 // comment")).toMatchSnapshot();
+    expect(transpileTypeScript("(1), (2)")).toMatchSnapshot();
+    expect(transpileTypeScript("(1 + 2)")).toMatchSnapshot();
+    expect(transpileTypeScript("{x: 42}")).toMatchSnapshot();
+    expect(transpileTypeScript("({x: 42})")).toMatchSnapshot();
+});
+it("transpiles TypeScript function expressions", () => {
+    expect(transpileTypeScript("function foo() {}")).toMatchSnapshot();
+});
+it("transpiles TypeScript class expressions", () => {
+    expect(transpileTypeScript("class Foo {}")).toMatchSnapshot();
+});
+it("transpiles TypeScript statements", () => {
+    expect(transpileTypeScript("1 + 2;")).toMatchSnapshot();
+    expect(transpileTypeScript("1, 2;")).toMatchSnapshot();
+    expect(transpileTypeScript("(1), (2);")).toMatchSnapshot();
+    expect(transpileTypeScript("(1 + 2);")).toMatchSnapshot();
+    expect(transpileTypeScript("{x: 42};")).toMatchSnapshot();
+    expect(transpileTypeScript("({x: 42});")).toMatchSnapshot();
+});
+it("transpiles TypeScript imports", () => {
+    expect(transpileTypeScript('import {foo} from "npm:bar";')).toMatchSnapshot();
+    expect(transpileTypeScript('import type {foo} from "npm:bar";')).toMatchSnapshot();
+});
+it("throws SyntaxError on invalid syntax", () => {
+    assert.throws(() => transpileTypeScript("1) + 2"), SyntaxError);
+    assert.throws(() => transpileTypeScript("(1 + 2"), SyntaxError);
+    assert.throws(() => transpileTypeScript("1 + 2 /* comment"), SyntaxError);
+});

package/dist/src/runtime/stdlib/highlight.js

@@ -47,6 +47,11 @@ export async function highlight(code) {
     highlightCode(text, tree, highlighter, emit, emitBreak);
 }
 async function getParser(language) {
+    switch (language) {
+        case "node":
+            language = "ts";
+            break;
+    }
     switch (language) {
         case "js":
         case "ts":
@@ -68,7 +73,6 @@ function getLanguage(code) {
         ?.slice("language-".length)
         ?.toLowerCase();
     switch (language) {
-        case "node":
         case "javascript":
             return "js";
         case "typescript":

package/package.json

@@ -5,7 +5,7 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "1.4.0-rc.1",
+  "version": "1.4.1",
   "type": "module",
   "scripts": {
     "test": "vitest",