@r-universe/webr 2023.6.21 → 2023.9.18

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/chan/channel-postmessage.test.d.ts

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

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-09-18 11:30:54 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-09-18 11:30:54 UTC; unix

package/dist/webR/chan/channel-common.d.ts

@@ -1,10 +1,12 @@
 import { SharedBufferChannelMain, SharedBufferChannelWorker } from './channel-shared';
 import { ServiceWorkerChannelMain, ServiceWorkerChannelWorker } from './channel-service';
+import { PostMessageChannelMain, PostMessageChannelWorker } from './channel-postmessage';
 import { WebROptions } from '../webr-main';
 export declare const ChannelType: {
     readonly Automatic: 0;
     readonly SharedArrayBuffer: 1;
     readonly ServiceWorker: 2;
+    readonly PostMessage: 3;
 };
 export type ChannelInitMessage = {
     type: string;
@@ -15,5 +17,5 @@ export type ChannelInitMessage = {
         location?: string;
     };
 };
-export declare function newChannelMain(data: Required<WebROptions>): SharedBufferChannelMain | ServiceWorkerChannelMain;
-export declare function newChannelWorker(msg: ChannelInitMessage): SharedBufferChannelWorker | ServiceWorkerChannelWorker;
+export declare function newChannelMain(data: Required<WebROptions>): SharedBufferChannelMain | ServiceWorkerChannelMain | PostMessageChannelMain;
+export declare function newChannelWorker(msg: ChannelInitMessage): SharedBufferChannelWorker | ServiceWorkerChannelWorker | PostMessageChannelWorker;

package/dist/webR/chan/channel-postmessage.d.ts

@@ -0,0 +1,26 @@
+import { Message } from './message';
+import { WebROptions } from '../webr-main';
+import { ChannelMain } from './channel';
+export declare class PostMessageChannelMain extends ChannelMain {
+    #private;
+    initialised: Promise<unknown>;
+    resolve: (_?: unknown) => void;
+    close: () => void;
+    constructor(config: Required<WebROptions>);
+    interrupt(): void;
+}
+export declare class PostMessageChannelWorker {
+    #private;
+    constructor();
+    resolve(): void;
+    write(msg: Message, transfer?: [Transferable]): void;
+    writeSystem(msg: Message, transfer?: [Transferable]): void;
+    read(): Message;
+    inputOrDispatch(): number;
+    run(_args: string[]): void;
+    setDispatchHandler(dispatch: (msg: Message) => void): void;
+    request(msg: Message, transferables?: [Transferable]): Promise<any>;
+    setInterrupt(interrupt: () => void): void;
+    handleInterrupt(): void;
+    onMessageFromMainThread(message: Message): void;
+}

package/dist/webR/chan/channel-shared.d.ts

@@ -11,6 +11,7 @@ export declare class SharedBufferChannelMain extends ChannelMain {
 }
 export declare class SharedBufferChannelWorker implements ChannelWorker {
     #private;
+    onMessageFromMainThread: (msg: Message) => void;
     constructor();
     resolve(): void;
     write(msg: Message, transfer?: [Transferable]): void;

package/dist/webR/chan/channel.d.ts

@@ -31,6 +31,7 @@ export interface ChannelWorker {
     run(args: string[]): void;
     inputOrDispatch: () => number;
     setDispatchHandler: (dispatch: (msg: Message) => void) => void;
+    onMessageFromMainThread: (msg: Message) => void;
 }
 /**
  * Handler functions dealing with setup and commmunication over a Service Worker.

package/dist/webR/console.d.ts

@@ -3,7 +3,8 @@ export interface ConsoleCallbacks {
     stdout?: (line: string) => void;
     stderr?: (line: string) => void;
     prompt?: (line: string) => void;
-    canvasExec?: (line: string) => void;
+    canvasImage?: (image: ImageBitmap) => void;
+    canvasNewPage?: () => void;
 }
 /**
  * Text-based Interactive Console for WebR
@@ -27,9 +28,12 @@ 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.
  *
+ * The ``canvasNewPage`` callback function is called when webR creates a new
+ * plot.
+ *
  * Once constructed, start the Console using the ``run`` method. The `run`
  * method starts an asynchronous infinite loop that waits for output from the
  * webR worker and then calls the relevant callbacks.

package/dist/webR/emscripten.d.ts

@@ -59,6 +59,8 @@ export interface Module extends EmscriptenModule {
     _R_ParseEvalString: (code: number, env: RPtr) => RPtr;
     _R_PreserveObject: (ptr: RPtr) => void;
     _R_ReleaseObject: (ptr: RPtr) => void;
+    _R_ReplDLLinit: () => void;
+    _R_ReplDLLdo1: () => number;
     _Rf_ScalarReal: (n: number) => RPtr;
     _Rf_ScalarLogical: (l: number) => RPtr;
     _Rf_ScalarInteger: (n: number) => RPtr;
@@ -71,6 +73,7 @@ export interface Module extends EmscriptenModule {
     _Rf_findVarInFrame: (rho: RPtr, symbol: RPtr) => RPtr;
     _Rf_listAppend: (source: RPtr, target: RPtr) => RPtr;
     _Rf_getAttrib: (ptr1: RPtr, ptr2: RPtr) => RPtr;
+    _Rf_initialize_R: (argc: number, argv: RPtr) => void;
     _Rf_install: (ptr: number) => RPtr;
     _Rf_installTrChar: (name: RPtr) => RPtr;
     _Rf_lang1: (ptr1: RPtr) => RPtr;
@@ -89,6 +92,8 @@ export interface Module extends EmscriptenModule {
     _Rf_setAttrib: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr) => RPtr;
     _Rf_unprotect: (n: number) => void;
     _Rf_unprotect_ptr: (ptr: RPtr) => void;
+    _DLLbuf: RPtr;
+    _DLLbufp: RPtr;
     _R_BaseEnv: RPtr;
     _R_BracketSymbol: RPtr;
     _R_Bracket2Symbol: RPtr;
@@ -107,6 +112,8 @@ export interface Module extends EmscriptenModule {
     _R_UnboundValue: RPtr;
     _SET_STRING_ELT: (ptr: RPtr, idx: number, val: RPtr) => void;
     _SET_VECTOR_ELT: (ptr: RPtr, idx: number, val: RPtr) => void;
+    _setup_Rmainloop: () => void;
+    _strcpy: (dest: RPtr, src: RPtr) => number;
     webr: {
         UnwindProtectException: typeof UnwindProtectException;
         readConsole: () => number;

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,8 @@ import * as RWorker from './robj-worker';
 import { EvalROptions } from './webr-chan';
 export { Console, ConsoleCallbacks } from './console';
 export * from './robj-main';
+export * from './error';
+export { ChannelType } from './chan/channel-common';
 /**
  * The webR FS API for interacting with the Emscripten Virtual File System.
  */
@@ -114,6 +116,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",