@observablehq/notebook-kit 2.1.7 → 2.1.9

package/dist/package.json

@@ -5,10 +5,10 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "2.1.7",
+    "version": "2.1.9",
     "type": "module",
     "scripts": {
-        "test": "vitest",
+        "test": "TZ=America/Los_Angeles vitest",
         "prepublishOnly": "rm -rf dist && tsc && chmod +x dist/bin/*.js && cp -r src/styles src/templates dist/src && cp src/runtime/stdlib/*.css dist/src/runtime/stdlib",
         "lint": "tsc --noEmit && eslint bin src types",
         "notebooks": "tsx bin/notebooks.ts",

package/dist/src/javascript/features.js

@@ -1,4 +1,4 @@
-import { getStringLiteralValue, isStringLiteral } from "./literal.js";
+import { getStringLiteralValue, isStringLiteral } from "./strings.js";
 import { findReferences } from "./references.js";
 import { syntaxError } from "./syntaxError.js";
 import { simple } from "./walk.js";

package/dist/src/javascript/observable.js

@@ -1,7 +1,9 @@
 import { parseCell } from "@observablehq/parser";
 import { rewriteFileExpressions } from "./files.js";
 import { flatMapImportSpecifiers, rewriteImportDeclarations } from "./imports.js";
+import { resolveNpmImport } from "./imports/npm.js";
 import { Sourcemap } from "./sourcemap.js";
+import { getStringLiteralValue, isStringLiteral } from "./strings.js";
 import { transpileJavaScript } from "./transpile.js";
 import { simple } from "./walk.js";
 export function transpileObservable(input, options) {
@@ -14,6 +16,7 @@ export function transpileObservable(input, options) {
         throw new Error("tagged ojs cells are not supported");
     const output = new Sourcemap(input).trim();
     rewriteSpecialReferences(output, cell.body);
+    rewriteDynamicImports(output, cell.body);
     if (options?.resolveFiles)
         rewriteFileExpressions(output, cell.body);
     const inputs = Array.from(new Set(cell.references.map(asReference)));
@@ -82,6 +85,26 @@ function transformObservableImport(body) {
         }
     ];
 }
+/**
+ * Rewrite a bare dynamic import such as import("d3") to a CDN URL, like
+ * import("https://cdn.jsdelivr.net/npm/d3/+esm"), using the same resolution as
+ * static imports. Protocol (npm:, https:, …) and local imports are left alone.
+ */
+function rewriteDynamicImports(output, body) {
+    simple(body, {
+        ImportExpression({ source }) {
+            if (!isStringLiteral(source))
+                return;
+            let value = getStringLiteralValue(source);
+            if (/^(\w+:|\.?\.?\/)/.test(value))
+                return;
+            if (/\.(js|mjs|cjs)$/.test(value))
+                value += "/+esm";
+            const resolution = resolveNpmImport(`npm:${value}`);
+            output.replaceLeft(source.start, source.end, JSON.stringify(resolution));
+        }
+    });
+}
 /** Rewrite viewof x ↦ viewof$x, and mutable x ↦ mutable$x.value. */
 function rewriteSpecialReferences(output, body) {
     simple(body, {

package/dist/src/runtime/define.d.ts

@@ -22,6 +22,8 @@ export type Definition = {
     autoview?: boolean;
     /** whether this cell’s singular output is a mutable */
     automutable?: boolean;
+    /** whether to define the display and view builtins; defaults to true */
+    display?: boolean;
     /** an asset mapping to apply to any autodisplayed assets (e.g., images and videos) */
     assets?: Map<string, string>;
 };

package/dist/src/runtime/define.js

@@ -2,12 +2,13 @@ import { clear, display, observe } from "./display.js";
 import { input } from "./stdlib/generators/index.js";
 import { Mutator } from "./stdlib/mutable.js";
 export function define(main, state, definition, observer = observe) {
-    const { id, body, inputs = [], outputs = [], output, autodisplay, autoview, automutable } = definition;
+    const { id, body, inputs = [], outputs = [], output } = definition;
+    const { autodisplay, autoview, automutable, display: defineDisplay = true } = definition;
     const variables = state.variables;
     const v = main.variable(observer(state, definition), { shadow: {} });
     const vid = output ?? (outputs.length ? `cell ${id}` : null);
     state.autoclear = true;
-    if (inputs.includes("display") || inputs.includes("view")) {
+    if (defineDisplay && (inputs.includes("display") || inputs.includes("view"))) {
         let displayVersion = -1; // the variable._version of currently-displayed values
         const vd = new v.constructor(2, v._module);
         vd.define(inputs.filter((i) => i !== "display" && i !== "view"), () => {

package/dist/src/runtime/stdlib/dsv.d.ts

@@ -0,0 +1,4 @@
+export declare function inferTypes<T extends Record<string, string>>(rows: T[], columns: (keyof T)[]): Record<keyof T, unknown>[];
+export declare function coerceBoolean(value: string): boolean | null | undefined;
+export declare function coerceNumber(value: string): number;
+export declare function coerceDate(value: string): Date | null;

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

@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/**
+ * Accepts dates in the following forms:
+ * - ±YYYYYY-MM-DD
+ * - YYYY-MM-DD
+ * - MM/DD/YY
+ * - MM/DD/YYYY
+ *
+ * Following a "T" or a space, dates may additionally have a time:
+ * - HH:MM
+ * - HH:MM:SS
+ * - HH:MM:SS.MMM
+ *
+ * And the time may optionally have a time zone:
+ * - Z
+ * - ±HH:MM
+ */
+const DATE_TEST = /^([-+]\d{2})?\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4}([T ]\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/; // prettier-ignore
+/** The maximum number of rows to sample (including missing values). */
+const SAMPLE_SIZE = 100;
+export function inferTypes(rows, columns) {
+    const output = rows;
+    const n = rows.length;
+    const k = Math.min(n, SAMPLE_SIZE);
+    for (const column of columns) {
+        let booleans = 0;
+        let numbers = 0;
+        let dates = 0;
+        let strings = 0;
+        for (let i = 0; i < k; ++i) {
+            const value = rows[i][column]?.trim();
+            if (!value)
+                continue;
+            ++strings;
+            if (/^(true|false)$/i.test(value))
+                ++booleans;
+            else if (!isNaN(Number(value)))
+                ++numbers;
+            else if (DATE_TEST.test(value))
+                ++dates;
+        }
+        // Chose the non-string type with the greatest count that is also ≥90%; or
+        // if no such type meets that criterion, use string.
+        let coerce = undefined;
+        let typeCount = Math.max(1, Math.ceil(strings * 0.9)) - 1;
+        if (booleans > typeCount)
+            ((coerce = coerceBoolean), (typeCount = booleans));
+        if (numbers > typeCount)
+            ((coerce = coerceNumber), (typeCount = numbers));
+        if (dates > typeCount)
+            ((coerce = coerceDate), (typeCount = dates));
+        if (!coerce)
+            continue;
+        for (let i = 0; i < n; ++i) {
+            output[i][column] = coerce(rows[i][column]);
+        }
+    }
+    return output;
+}
+export function coerceBoolean(value) {
+    const trimmed = value.trim().toLowerCase();
+    return trimmed === "true" ? true : trimmed === "false" ? false : trimmed ? undefined : null;
+}
+export function coerceNumber(value) {
+    const trimmed = value.trim();
+    return trimmed ? Number(value) : NaN;
+}
+export function coerceDate(value) {
+    const trimmed = value.trim();
+    return trimmed ? new Date(DATE_TEST.test(trimmed) ? trimmed : NaN) : null;
+}

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

@@ -203,6 +203,8 @@ async function insertSource(database, name, source) {
     source = await source;
     if (isFileAttachment(source))
         return insertFile(database, name, source);
+    if (isFlechetteTable(source))
+        return insertFlechetteTable(database, name, source);
     if (isArrowTable(source))
         return insertArrowTable(database, name, source);
     if (Array.isArray(source))
@@ -215,6 +217,8 @@ async function insertSource(database, name, source) {
         if ("data" in source) {
             // data + options
             const { data, ...options } = source;
+            if (isFlechetteTable(data))
+                return insertFlechetteTable(database, name, data, options);
             if (isArrowTable(data))
                 return insertArrowTable(database, name, data, options);
             return insertArray(database, name, data, options);
@@ -301,22 +305,28 @@ async function insertUntypedCSV(connection, file, name) {
 async function insertArrowTable(database, name, table, options) {
     const connection = await database.connect();
     try {
-        await connection.insertArrowTable(table, {
-            name,
-            schema: "main",
-            ...options
-        });
+        await connection.insertArrowTable(table, { name, schema: "main", ...options });
+    }
+    finally {
+        await connection.close();
+    }
+}
+async function insertArrowIpc(database, name, buffer, options) {
+    const connection = await database.connect();
+    try {
+        await connection.insertArrowFromIPCStream(buffer, { name, schema: "main", ...options });
     }
     finally {
         await connection.close();
     }
 }
+async function insertFlechetteTable(database, name, table, options) {
+    const { tableToIPC } = await import("https://cdn.jsdelivr.net/npm/@uwdata/flechette@2.5.0/+esm");
+    return await insertArrowIpc(database, name, tableToIPC(table, { format: "stream" }), options);
+}
 async function insertArqueroTable(database, name, source) {
-    // TODO When we have stdlib versioning and can upgrade Arquero to version 5,
-    // we can then call source.toArrow() directly, with insertArrowTable()
-    const arrow = await import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm");
-    const table = arrow.tableFromIPC(source.toArrowBuffer());
-    return await insertArrowTable(database, name, table);
+    const buffer = typeof source.toArrowIPC === "function" ? source.toArrowIPC() : source.toArrowBuffer(); // prettier-ignore
+    return await insertArrowIpc(database, name, buffer);
 }
 async function insertArray(database, name, array, options) {
     const arrow = await import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm");
@@ -372,9 +382,17 @@ function isFileAttachment(value) {
         typeof value.url === "function" &&
         typeof value.arrayBuffer === "function");
 }
-// Arquero tables have a `toArrowBuffer` function
+// Arquero tables have a `toArrowBuffer` (v5-) or `toArrowIPC` (v6+) function
 function isArqueroTable(value) {
-    return value && typeof value.toArrowBuffer === "function";
+    return (value && (typeof value.toArrowBuffer === "function" || typeof value.toArrowIPC === "function"));
+}
+// Flechette tables have a `toColumns` method
+function isFlechetteTable(value) {
+    return (value &&
+        typeof value.getChild === "function" &&
+        typeof value.toColumns === "function" &&
+        value.schema &&
+        Array.isArray(value.schema.fields));
 }
 // Returns true if the value is an Apache Arrow table. This uses a “duck” test
 // (instead of strict instanceof) because we want it to work with a range of

package/dist/src/runtime/stdlib/fileAttachment.d.ts

@@ -1,7 +1,7 @@
 export type DsvOptions = {
     delimiter?: string;
     array?: boolean;
-    typed?: boolean;
+    typed?: "auto" | boolean;
 };
 export type DsvResult = (Record<string, any>[] | any[][]) & {
     columns: string[];
@@ -73,11 +73,7 @@ export declare abstract class AbstractFile implements FileAttachment {
     text(encoding?: string): Promise<string>;
     json(): Promise<any>;
     stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
-    dsv({ delimiter, array, typed }?: {
-        delimiter?: string | undefined;
-        array?: boolean | undefined;
-        typed?: boolean | undefined;
-    }): Promise<DsvResult>;
+    dsv({ delimiter, array, typed }?: DsvOptions): Promise<DsvResult>;
     csv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
     tsv(options?: Omit<DsvOptions, "delimiter">): Promise<DsvResult>;
     image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;

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

@@ -1,3 +1,4 @@
+import { inferTypes } from "./dsv.js";
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const files = new Map();
 let strict = false;
@@ -92,8 +93,11 @@ export class AbstractFile {
     async dsv({ delimiter = ",", array = false, typed = false } = {}) {
         const [text, d3] = await Promise.all([this.text(), import("https://cdn.jsdelivr.net/npm/d3-dsv/+esm")]); // prettier-ignore
         const format = d3.dsvFormat(delimiter);
-        const parse = array ? format.parseRows : format.parse;
-        return parse(text, typed && d3.autoType);
+        const parse = array ? ((typed && (typed = true)), format.parseRows) : format.parse;
+        const output = parse(text, typed === true ? d3.autoType : undefined);
+        if (typed === "auto")
+            inferTypes(output, output.columns);
+        return output;
     }
     async csv(options) {
         return this.dsv({ ...options, delimiter: "," });

package/dist/src/runtime/stdlib/index.d.ts

@@ -72,11 +72,7 @@ export declare const library: {
             text(encoding?: string): Promise<string>;
             json(): Promise<any>;
             stream(): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
-            dsv({ delimiter, array, typed }?: {
-                delimiter?: string | undefined;
-                array?: boolean | undefined;
-                typed?: boolean | undefined;
-            }): Promise<import("./fileAttachment.js").DsvResult>;
+            dsv({ delimiter, array, typed }?: import("./fileAttachment.js").DsvOptions): Promise<import("./fileAttachment.js").DsvResult>;
             csv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
             tsv(options?: Omit<import("./fileAttachment.js").DsvOptions, "delimiter">): Promise<import("./fileAttachment.js").DsvResult>;
             image(props?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;

package/dist/src/vite/observable.js

@@ -173,6 +173,7 @@ define(
     inputs: ${JSON.stringify(transpiled.inputs)},
     outputs: ${JSON.stringify(transpiled.outputs)},
     output: ${JSON.stringify(transpiled.output)},
+    display: ${cell.mode === "js" || cell.mode === "ts"},
     assets: ${assets.size > 0 ? "assets" : "undefined"},
     autodisplay: ${transpiled.autodisplay},
     autoview: ${transpiled.autoview},

package/package.json

@@ -5,10 +5,10 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "2.1.7",
+  "version": "2.1.9",
   "type": "module",
   "scripts": {
-    "test": "vitest",
+    "test": "TZ=America/Los_Angeles vitest",
     "prepublishOnly": "rm -rf dist && tsc && chmod +x dist/bin/*.js && cp -r src/styles src/templates dist/src && cp src/runtime/stdlib/*.css dist/src/runtime/stdlib",
     "lint": "tsc --noEmit && eslint bin src types",
     "notebooks": "tsx bin/notebooks.ts",

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

@@ -1,8 +0,0 @@
-import type { BinaryExpression, Literal, Node, TemplateLiteral } from "acorn";
-export type StringLiteral = (Literal & {
-    value: string;
-}) | TemplateLiteral | BinaryExpression;
-export declare function isLiteral(node: Node): node is Literal;
-export declare function isTemplateLiteral(node: Node): node is TemplateLiteral;
-export declare function isStringLiteral(node: Node): node is StringLiteral;
-export declare function getStringLiteralValue(node: StringLiteral): string;

package/dist/src/javascript/literal.js

@@ -1,42 +0,0 @@
-export function isLiteral(node) {
-    return node.type === "Literal";
-}
-export function isTemplateLiteral(node) {
-    return node.type === "TemplateLiteral";
-}
-export function isStringLiteral(node) {
-    return isLiteral(node)
-        ? /^['"]/.test(node.raw)
-        : isTemplateLiteral(node)
-            ? node.expressions.every(isStringLiteral)
-            : isBinaryExpression(node)
-                ? node.operator === "+" && isStringLiteral(node.left) && isStringLiteral(node.right)
-                : isMemberExpression(node)
-                    ? "value" in node // param
-                    : false;
-}
-export function getStringLiteralValue(node) {
-    return node.type === "TemplateLiteral"
-        ? getTemplateLiteralValue(node)
-        : node.type === "BinaryExpression"
-            ? getBinaryExpressionValue(node)
-            : node.value; // Literal or ParamReference
-}
-function getTemplateLiteralValue(node) {
-    let value = node.quasis[0].value.cooked;
-    for (let i = 0; i < node.expressions.length; ++i) {
-        value += getStringLiteralValue(node.expressions[i]);
-        value += node.quasis[i + 1].value.cooked;
-    }
-    return value;
-}
-function getBinaryExpressionValue(node) {
-    return (getStringLiteralValue(node.left) +
-        getStringLiteralValue(node.right));
-}
-function isMemberExpression(node) {
-    return node.type === "MemberExpression";
-}
-function isBinaryExpression(node) {
-    return node.type === "BinaryExpression";
-}