@jataware/beaker-client 2.0.0-b.1

package/dist/util.d.ts

@@ -0,0 +1,50 @@
+import { JSONObject } from '@lumino/coreutils';
+import { KernelFutureHandler } from '@jupyterlab/services/lib/kernel/future';
+import { IBeakerShellMessage, BeakerCodeCell, IBeakerIOPubMessage, IBeakerCell } from './notebook';
+import * as Kernel from '@jupyterlab/services/lib/kernel/kernel';
+export declare enum KernelState {
+    unknown = "unknown",
+    starting = "starting",
+    idle = "idle",
+    busy = "busy",
+    terminating = "terminating",
+    restarting = "restarting",
+    autorestarting = "autorestarting",
+    dead = "dead"
+}
+export declare const createMessageId: (msgType: string) => string;
+export interface IBeakerFuture<REQUEST extends IBeakerShellMessage = IBeakerShellMessage, REPLY extends IBeakerShellMessage = IBeakerShellMessage> extends Kernel.IShellFuture<REQUEST, REPLY> {
+    msgId?: string;
+    onResponse?: (msg: any) => void | PromiseLike<void>;
+}
+export interface IBeakerAvailableContexts {
+    [key: string]: {
+        languages: {
+            slug: string;
+            kernel: string;
+        };
+        defaultPayload: string;
+    };
+}
+export interface IActiveContextInfo {
+    slug: string;
+    class: string;
+    config: JSONObject;
+    language: {
+        slug: string;
+        subkernel: string;
+    };
+    kernelInfo?: any;
+    name?: string;
+}
+export declare class BeakerCellFuture extends KernelFutureHandler<IBeakerShellMessage, IBeakerShellMessage> {
+    /**
+     * Construct a new KernelFutureHandler.
+     */
+    constructor(msg: IBeakerShellMessage, expectReply: boolean, disposeOnDone: boolean, kernel?: Kernel.IKernelConnection | null, cell?: BeakerCodeCell);
+    private cell;
+}
+export declare namespace BeakerCellFutures {
+    const handleIOPub: (msg: IBeakerIOPubMessage, cell: IBeakerCell) => void;
+    const handleReply: (msg: IBeakerShellMessage, cell: IBeakerCell) => void;
+}

package/dist/util.js

@@ -0,0 +1,112 @@
+import { v4 } from 'uuid';
+import { KernelFutureHandler } from '@jupyterlab/services/lib/kernel/future';
+
+var KernelState = /* @__PURE__ */ ((KernelState2) => {
+  KernelState2["unknown"] = "unknown";
+  KernelState2["starting"] = "starting";
+  KernelState2["idle"] = "idle";
+  KernelState2["busy"] = "busy";
+  KernelState2["terminating"] = "terminating";
+  KernelState2["restarting"] = "restarting";
+  KernelState2["autorestarting"] = "autorestarting";
+  KernelState2["dead"] = "dead";
+  return KernelState2;
+})(KernelState || {});
+const createMessageId = (msgType) => {
+  const uuid = v4().replaceAll("-", "").slice(0, 16);
+  return `beaker-${uuid}-${msgType}`;
+};
+class BeakerCellFuture extends KernelFutureHandler {
+  /**
+   * Construct a new KernelFutureHandler.
+   */
+  constructor(msg, expectReply, disposeOnDone, kernel, cell) {
+    if (!kernel) {
+      throw Error("Unable to send message. Not connected to kernel.");
+    }
+    if (!cell) {
+      throw Error("Cannot execute in cell as cell is undefined or invalid.");
+    }
+    const msgId = msg.header.msg_id;
+    if (msg.channel === void 0) {
+      msg.channel = "shell";
+    }
+    const disposalCallback = () => {
+      kernel._futures.delete(msgId);
+    };
+    super(disposalCallback, msg, expectReply, disposeOnDone, kernel);
+    kernel._futures?.set(msgId, this);
+    this.cell = cell;
+    this.onIOPub = (msg2) => BeakerCellFutures.handleIOPub(msg2, this.cell);
+    this.onReply = (msg2) => BeakerCellFutures.handleReply(msg2, this.cell);
+  }
+  cell;
+}
+var BeakerCellFutures;
+((BeakerCellFutures2) => {
+  BeakerCellFutures2.handleIOPub = (msg, cell) => {
+    const msg_type = msg.header.msg_type;
+    const content = msg.content;
+    if (msg_type === "status") {
+      cell.status = content.execution_state;
+    } else if (msg_type === "execute_result") {
+      cell.busy = false;
+      if (content.execution_count) {
+        cell.execution_count = content.execution_count;
+      }
+      cell.outputs.push({
+        output_type: "execute_result",
+        ...content
+      });
+    } else if (msg_type === "stream") {
+      cell.outputs.push({
+        output_type: "stream",
+        ...content
+      });
+    } else if (msg_type === "display_data") {
+      cell.outputs.push({
+        output_type: "display_data",
+        ...content
+      });
+    }
+  };
+  BeakerCellFutures2.handleReply = (msg, cell) => {
+    cell.busy = false;
+    if (msg.content.status === "ok") {
+      cell.last_execution = { ...cell.last_execution, status: "ok" };
+      cell.execution_count = Number(msg.content.execution_count);
+    } else if (msg.content.status === "error") {
+      cell.execution_count = Number(msg.content.execution_count);
+      const error_details = {
+        ename: msg.content.ename,
+        evalue: msg.content.evalue,
+        traceback: msg.content.traceback
+      };
+      cell.last_execution = {
+        status: "error",
+        ...error_details
+      };
+      cell.outputs.push({
+        output_type: "error",
+        ...error_details
+      });
+    } else if (msg.content.status === "abort") {
+      cell.execution_count = msg.content.execution_count;
+      const error_details = {
+        ename: "Execution aborted",
+        evalue: "Execution aborted",
+        traceback: []
+      };
+      cell.last_execution = {
+        status: "error",
+        ...error_details
+      };
+      cell.outputs.push({
+        output_type: "error",
+        content: error_details
+      });
+    }
+  };
+})(BeakerCellFutures || (BeakerCellFutures = {}));
+
+export { BeakerCellFuture, BeakerCellFutures, KernelState, createMessageId };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@jataware/beaker-client",
+  "version": "2.0.0-b.1",
+  "type": "module",
+  "description": "Beaker Notebook client library",
+  "repository": {
+    "url": "git+https://github.com/jataware/beaker-kernel.git"
+  },
+  "scripts": {
+    "build": "run-s type-check build-lib",
+    "build-lib": "vite build",
+    "type-check": "tsc --noEmit"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "dependencies": {
+    "@jupyterlab/apputils": "^4.5.1",
+    "@jupyterlab/nbformat": "^4.4.1",
+    "@jupyterlab/rendermime": "^4.4.1",
+    "@jupyterlab/services": "^7.4.1",
+    "json-schema": "^0.4.0",
+    "node-fetch": "^2.6.6",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node-fetch": "^2.6.6",
+    "@types/uuid": "^9.0.7",
+    "npm-run-all2": "^7.0.2",
+    "typescript": "^5.8.0",
+    "vite": "^7.1.5",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}

package/src/extension.ts

@@ -0,0 +1,34 @@
+import { JSONObject } from '@lumino/coreutils';
+import { IBeakerShellMessage } from './notebook';
+import { IBeakerFuture } from './util';
+import * as messages from '@jupyterlab/services/lib/kernel/messages';
+import * as nbformat from '@jupyterlab/nbformat';
+import { PartialJSONObject } from '@lumino/coreutils';
+
+
+declare module "@jupyterlab/services/lib/kernel" {
+    export interface KernelConnection {
+        sendBeakerMessage(
+            messageType: string,
+            content: JSONObject,
+            messageId: string,
+            expectReply: boolean,
+            disposeOnDone: boolean
+        ): IBeakerFuture;
+
+    }
+}
+
+declare module "@jupyterlab/services/lib/kernel/messages" {
+    export function createMessage<T extends IBeakerShellMessage>(options: messages.IOptions<T>): T;
+
+}
+
+declare module '@jupyterlab/nbformat' {
+    export interface IBaseOutput extends PartialJSONObject {
+        output_type: string;
+        metadata?: nbformat.OutputMetadata;
+    }
+}
+
+export default {};

package/src/history.ts

@@ -0,0 +1,61 @@
+import * as nbformat from '@jupyterlab/nbformat';
+
+
+export interface IBeakerHistoryEvent {
+    kernel_id: string;
+    kernel_slug: string;
+    context_slug: string;
+    creation_time: Date;
+}
+
+export interface IBeakerHistoryExecutionEvent extends IBeakerHistoryEvent {
+    cell_id: string;
+    execution_time: Date;
+    execution_duration: number;
+
+    silent: boolean;
+    execution_id: number;
+    source: nbformat.MultilineString;
+    result: any;
+    stdin: nbformat.MultilineString;
+    stderr: nbformat.MultilineString;
+    success: boolean;
+}
+
+export interface IBeakerHistoryQueryEvent extends IBeakerHistoryEvent {
+    cell_id: string;
+    execution_time: Date;
+    execution_duration: number;
+
+    source: nbformat.MultilineString;
+    thoughts: string[];
+    result: nbformat.MultilineString;
+}
+
+export type BeakerHistoryEvent = IBeakerHistoryExecutionEvent | IBeakerHistoryQueryEvent;
+
+export interface IBeakerHistory {
+    sessionId: string;
+    events: IBeakerHistoryEvent[];
+}
+
+
+export class BeakerHistory implements IBeakerHistory {
+
+    constructor(sessionId: string) {
+        this.sessionId = sessionId;
+        this.events = [];
+    }
+
+    public addEvent(event: BeakerHistoryEvent) {
+        this.events.push(event);
+    };
+
+    public clear() {
+        // Clear with a splice to ensure reactivity
+        this.events.splice(0, this.events.splice.length);
+    }
+
+    sessionId: string;
+    events: IBeakerHistoryEvent[];
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+// @ts-ignore: Include extension code to extend typing from Jupyterlabs
+import extension from './extension';
+if (extension === undefined) {
+    throw new Error("Unable to extend Jupyterlab types");
+}
+
+export * from './session';
+export * from './notebook';
+export * from './render';
+export * from './util';
+export * from './history';
+