@r-universe/webr 2023.6.21 → 2023.8.26

package/dist/repl/App.d.ts

@@ -0,0 +1,15 @@
+import { Readline } from 'xterm-readline';
+import './App.css';
+export interface TerminalInterface {
+    println: Readline['println'];
+    read: Readline['read'];
+    write: Readline['write'];
+}
+export interface FilesInterface {
+    refreshFilesystem: () => Promise<void>;
+    openFileInEditor: (name: string, path: string, readOnly: boolean) => Promise<void>;
+}
+export interface PlotInterface {
+    newPlot: () => void;
+    drawImage: (img: ImageBitmap) => void;
+}

package/dist/repl/components/Editor.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { WebR } from '../../webR/webr-main';
+import { EditorState } from '@codemirror/state';
+import { FilesInterface, TerminalInterface } from '../App';
+import './Editor.css';
+export type EditorFile = {
+    name: string;
+    path: string;
+    ref: {
+        editorState: EditorState;
+        scrollTop?: number;
+        scrollLeft?: number;
+    };
+};
+export declare function FileTabs({ files, activeFileIdx, setActiveFileIdx, closeFile }: {
+    files: EditorFile[];
+    activeFileIdx: number;
+    setActiveFileIdx: React.Dispatch<React.SetStateAction<number>>;
+    closeFile: (e: React.SyntheticEvent, index: number) => void;
+}): React.JSX.Element;
+export declare function Editor({ webR, terminalInterface, filesInterface, }: {
+    webR: WebR;
+    terminalInterface: TerminalInterface;
+    filesInterface: FilesInterface;
+}): React.JSX.Element;
+export default Editor;

package/dist/repl/components/Files.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { WebR } from '../../webR/webr-main';
+import type { FSNode } from '../../webR/webr-main';
+import { FilesInterface } from '../App';
+import './Files.css';
+interface ITreeNode {
+    id: number;
+    name: string;
+    children?: ITreeNode[];
+    metadata?: {
+        [x: string]: string | number | null | undefined;
+    };
+}
+export declare function createTreefromFSNode(fsNode: FSNode): ITreeNode;
+export declare function Files({ webR, filesInterface, }: {
+    webR: WebR;
+    filesInterface: FilesInterface;
+}): React.JSX.Element;
+export default Files;

package/dist/repl/components/Plot.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import './Plot.css';
+import { PlotInterface } from '../App';
+export declare function Plot({ plotInterface, }: {
+    plotInterface: PlotInterface;
+}): React.JSX.Element;
+export default Plot;

package/dist/repl/components/Terminal.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { TerminalInterface } from '../App';
+import { WebR } from '../../webR/webr-main';
+import 'xterm/css/xterm.css';
+export declare function Terminal({ webR, terminalInterface, }: {
+    webR: WebR;
+    terminalInterface: TerminalInterface;
+}): React.JSX.Element;
+export default Terminal;

package/dist/repl/components/utils.d.ts

@@ -0,0 +1,11 @@
+import { Text } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+export type CursorPosition = {
+    line: number;
+    col: number;
+};
+export declare function offsetToPosition(cmDoc: Text, offset: number): CursorPosition;
+export declare function positionToOffset(cmDoc: Text, pos: CursorPosition): number;
+export declare function getSelectedText(cmView: EditorView): string;
+export declare function getCurrentLineText(cmView: EditorView): string;
+export declare function moveCursorToNextLine(cmView: EditorView): void;

package/dist/tests/webR/error.test.d.ts

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

package/dist/vfs/usr/lib/R/library/parallel/DESCRIPTION

@@ -13,4 +13,4 @@ Imports: tools, compiler
 Suggests: methods
 Enhances: snow, Rmpi
 NeedsCompilation: yes
-Built: R 4.3.0; x86_64-pc-linux-gnu; 2023-06-21 12:51:09 UTC; unix
+Built: R 4.3.0; x86_64-pc-linux-gnu; 2023-08-26 20:21:20 UTC; unix

package/dist/vfs/usr/lib/R/library/tcltk/DESCRIPTION

@@ -9,4 +9,4 @@ Description: Interface and language bindings to Tcl/Tk GUI elements.
 License: Part of R 4.3.0
 Imports: utils
 NeedsCompilation: yes
-Built: R 4.3.0; x86_64-pc-linux-gnu; 2023-06-21 12:51:09 UTC; unix
+Built: R 4.3.0; x86_64-pc-linux-gnu; 2023-08-26 20:21:20 UTC; unix

package/dist/webR/console.d.ts

@@ -3,7 +3,7 @@ export interface ConsoleCallbacks {
     stdout?: (line: string) => void;
     stderr?: (line: string) => void;
     prompt?: (line: string) => void;
-    canvasExec?: (line: string) => void;
+    canvasImage?: (image: ImageBitmap) => void;
 }
 /**
  * Text-based Interactive Console for WebR
@@ -27,7 +27,7 @@ export interface ConsoleCallbacks {
  * function. The default implementation of `prompt` shows a JavaScript prompt
  * asking the user for input, and then sends the user input to `stdin`.
  *
- * The ``canvasExec`` callback function is called when webR writes plots to
+ * The ``canvasImage`` callback function is called when webR writes plots to
  * the built-in HTML canvas graphics device.
  *
  * Once constructed, start the Console using the ``run`` method. The `run`

package/dist/webR/error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Custom Error classes that shall be raised by webR.
+ * @module Error
+ */
+/**
+ * A general error raised by webR.
+ */
+export declare class WebRError extends Error {
+    constructor(msg: string);
+}
+/**
+ * Exceptions raised on the webR worker thread that have been forwarded to the
+ * main thread through the communication channel.
+ */
+export declare class WebRWorkerError extends WebRError {
+}
+/**
+ * Exceptions related to issues with the webR communication channel.
+ */
+export declare class WebRChannelError extends WebRError {
+}
+/**
+ * Exceptions related to issues with webR object payloads.
+ */
+export declare class WebRPayloadError extends WebRError {
+}

package/dist/webR/payload.d.ts

@@ -26,7 +26,7 @@ export type WebRPayloadErr = {
 };
 export type WebRPayload = WebRPayloadRaw | WebRPayloadPtr;
 export type WebRPayloadWorker = WebRPayloadRaw | WebRPayloadPtr | WebRPayloadErr;
-export declare function webRPayloadError(payload: WebRPayloadErr): Error;
+export declare function webRPayloadAsError(payload: WebRPayloadErr): Error;
 /**
  * Test for an WebRPayload instance.
  * @param {any} value The object to test.

package/dist/webR/webr-chan.d.ts

@@ -139,3 +139,21 @@ export interface ShelterDestroyMessage extends Message {
         obj: WebRPayloadPtr;
     };
 }
+export interface CanvasMessage extends Message {
+    type: 'canvas';
+    data: {
+        event: 'canvasNewPage';
+    } | {
+        event: 'canvasImage';
+        image: ImageBitmap;
+    };
+}
+export interface PagerMessage extends Message {
+    type: 'pager';
+    data: {
+        path: string;
+        header: string;
+        title: string;
+        deleteFile: boolean;
+    };
+}

package/dist/webR/webr-main.d.ts

@@ -14,6 +14,7 @@ import * as RWorker from './robj-worker';
 import { EvalROptions } from './webr-chan';
 export { Console, ConsoleCallbacks } from './console';
 export * from './robj-main';
+export * from './error';
 /**
  * The webR FS API for interacting with the Emscripten Virtual File System.
  */
@@ -114,6 +115,11 @@ export interface WebROptions {
      * Default: `channelType.Automatic`
      */
     channelType?: (typeof ChannelType)[keyof typeof ChannelType];
+    /**
+     * Create the lazy virtual filesystem entries before starting R?
+     * Default: `true`.
+     */
+    createLazyFilesystem?: boolean;
 }
 /**
  * The webR class is used to initialize and interact with the webR system.

package/dist/webr-serviceworker.js

@@ -1525,6 +1525,17 @@
     }
   });
 
+  // webR/error.ts
+  var WebRError = class extends Error {
+    constructor(msg) {
+      super(msg);
+      this.name = this.constructor.name;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+  var WebRChannelError = class extends WebRError {
+  };
+
   // webR/compat.ts
   var IN_NODE = typeof process !== "undefined" && process.release && process.release.name === "node";
   var loadScript;
@@ -1554,7 +1565,7 @@
       await Promise.resolve().then(() => __toESM(__require(nodePathMod.resolve(url))));
     };
   } else {
-    throw new Error("Cannot determine runtime environment");
+    throw new WebRError("Cannot determine runtime environment");
   }
 
   // webR/utils.ts
@@ -1588,7 +1599,7 @@
   async function sendRequest(clientId, uuid) {
     const client = await self.clients.get(clientId);
     if (!client) {
-      throw new Error("Service worker client not found");
+      throw new WebRChannelError("Service worker client not found");
     }
     if (!(uuid in requests)) {
       requests[uuid] = promiseHandles();
@@ -1619,7 +1630,7 @@
         const source = event.source;
         self.clients.get(source.id).then((client) => {
           if (!client) {
-            throw new Error("Can't respond to client in service worker message handler");
+            throw new WebRChannelError("Can't respond to client in service worker message handler");
           }
           client.postMessage({
             type: "registration-successful",