@observablehq/notebook-kit 1.8.0 → 1.9.0

package/dist/package.json

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

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

@@ -0,0 +1,10 @@
+import type { Node, CallExpression } from "acorn";
+export type FeatureExpression = CallExpression & {
+    argument: string;
+};
+/**
+ * Returns all calls to the specified feature (e.g., FileAttachment) in the
+ * specified body. Throws a SyntaxError if any of the calls are invalid (e.g.,
+ * when FileAttachment is passed a dynamic argument).
+ */
+export declare function findFeatures(name: string, body: Node, input: string): FeatureExpression[];

package/dist/src/javascript/features.js

@@ -0,0 +1,29 @@
+import { getStringLiteralValue, isStringLiteral } from "./literal.js";
+import { findReferences } from "./references.js";
+import { syntaxError } from "./syntaxError.js";
+import { simple } from "./walk.js";
+/**
+ * Returns all calls to the specified feature (e.g., FileAttachment) in the
+ * specified body. Throws a SyntaxError if any of the calls are invalid (e.g.,
+ * when FileAttachment is passed a dynamic argument).
+ */
+export function findFeatures(name, body, input) {
+    const filter = (ref) => ref.name === name;
+    const references = new Set(findReferences(body, { filterDeclaration: filter, filterReference: filter })); // prettier-ignore
+    const calls = [];
+    simple(body, {
+        CallExpression(node) {
+            const { callee } = node;
+            if (callee.type !== "Identifier" || !references.has(callee))
+                return;
+            const args = node.arguments;
+            if (args.length !== 1)
+                throw syntaxError(`${name} requires a single literal string argument`, node, input); // prettier-ignore
+            const [arg] = args;
+            if (!isStringLiteral(arg))
+                throw syntaxError(`${name} requires a single literal string argument`, node, input); // prettier-ignore
+            calls.push(Object.assign(node, { argument: getStringLiteralValue(arg) }));
+        }
+    });
+    return calls;
+}

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,42 @@
+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";
+}

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

@@ -1,9 +1,13 @@
 import type { Expression, Identifier, Options, Program } from "acorn";
+import type { FeatureExpression } from "./features.js";
 export declare const acornOptions: Options;
 export interface JavaScriptCell {
     body: Program | Expression;
     declarations: Identifier[] | null;
     references: Identifier[];
+    files: FeatureExpression[];
+    databases: FeatureExpression[];
+    secrets: FeatureExpression[];
     expression: boolean;
     async: boolean;
 }

package/dist/src/javascript/parse.js

@@ -1,7 +1,8 @@
 import { Parser, tokTypes } from "acorn";
-import { findReferences } from "./references.js";
-import { findDeclarations } from "./declarations.js";
 import { findAwaits } from "./awaits.js";
+import { findDeclarations } from "./declarations.js";
+import { findFeatures } from "./features.js";
+import { findReferences } from "./references.js";
 export const acornOptions = {
     ecmaVersion: "latest",
     sourceType: "module"
@@ -27,6 +28,9 @@ export function parseJavaScript(input) {
         body,
         declarations: expression ? null : findDeclarations(body, input),
         references: findReferences(body, { input }),
+        files: findFeatures("FileAttachment", body, input),
+        databases: findFeatures("DatabaseClient", body, input),
+        secrets: findFeatures("Secret", body, input),
         expression: !!expression,
         async: findAwaits(body).length > 0
     };

package/package.json

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