WebR - Expreimental

Author: WebReflection

docs/index.js

@@ -0,0 +1,102 @@
+/* c8 ignore start */
+/*! (c) Andrea Giammarchi - ISC */
+
+const {isArray} = Array;
+const {parse: jsonParse} = JSON;
+
+/** @typedef {{s: string[], d: Date[]}} Foreign foreign strings and dates */
+
+/**
+ * Transform quoted keys into regular keys.
+ * @param {string} str the key to eventually normalize
+ * @param {Foreign} foreign foreign strings and dates
+ * @returns 
+ */
+const getKey = (str, {s}) => str.replace(/"s(\d+)"/g, (_, $1) => s[$1]);
+
+/**
+ * Given a `'string'` or a `"string"` returns a JSON compatible string.
+ * @param {string} str a TOML entry to parse
+ * @param {Foreign} foreign foreign strings and dates
+ * @returns {string}
+ */
+const getValue = (str, foreign) => jsonParse(
+  str.replace(/(\S+?)\s*=/g, '"$1":'),
+  (_, value) => typeof value === 'string' ?
+    foreign[value[0]][value.slice(1)] :
+    value
+);
+
+/**
+ * Crawl the `json` object via the given array of keys and handle array entries.
+ * @param {string[]} keys a path with all keys to reach the entry
+ * @param {Foreign} foreign foreign strings and dates
+ * @param {object} entry the root entry of the TOML
+ * @param {boolean} asArray handle array entries
+ * @returns {object} the current entry to handle
+ */
+const getPath = (keys, foreign, entry, asArray) => {
+  for (let i = 0, {length} = keys, last = length - 1; i < length; i++) {
+    const key = getKey(keys[i], foreign);
+    entry = entry[key] || (entry[key] = (asArray && (i === last) ? [] : {}));
+    if (isArray(entry)) {
+      if ((i === last) || !entry.length)
+        entry.push({});
+      entry = entry.at(-1);
+    }
+  }
+  return entry;
+};
+
+/**
+ * Given a TOML text, removes stirngs and dates for easier parsing +
+ * remove multi-line arrays to not need evaluation.
+ * @param {string} toml the TOML text to map
+ * @param {string[]} strings mapped strings
+ * @param {Date[]} dates mapped Dates
+ * @returns {[string, Foreign]}
+ */
+const mapForeign = (toml, strings, dates) => [
+  toml
+    // map strings in the TOML
+    .replace(
+      /(["'])(?:(?=(\\?))\2.)*?\1/g,
+      value => `"s${strings.push(value.slice(1, -1)) - 1}"`
+    )
+    // map dates in the TOML
+    .replace(
+      /\d{2,}([:-]\d{2}){2}([ T:-][\dZ:-]+)?/g,
+      value => `"d${dates.push(new Date(value)) - 1}"`
+    )
+    // avoid multi-line array entries
+    .replace(/,\s*[\r\n]+/g, ', ')
+    .replace(/\[\s*[\r\n]+/g, '[')
+    .replace(/[\r\n]+\s*]/g, ']'),
+  {s: strings, d: dates}
+];
+
+/**
+ * Given a simple subset of a TOML file, returns its JS equivalent.
+ * @param {string} toml the TOML text to parse
+ * @returns {object} the TOML equivalent as JSON serializable
+ */
+const parse = toml => {
+  const [text, foreign] = mapForeign(toml, [], []);
+  const json = {};
+  let entry = json;
+  for (let line of text.split(/[\r\n]+/)) {
+    if ((line = line.trim()) && !line.startsWith('#')) {
+      if (/^(\[+)(.*?)\]+/.test(line))
+        entry = getPath(RegExp.$2.trim().split('.'), foreign, json, RegExp.$1 !== '[');
+      else if (/^(\S+?)\s*=([^#]+)/.test(line)) {
+        const {$1: key, $2: value} = RegExp;
+        entry[getKey(key, foreign)] = getValue(value.trim(), foreign);
+      }
+    }
+  }
+  return json;
+};
+
+/* c8 ignore stop */
+
+export { parse };

docs/index.js.map

@@ -0,0 +1,69 @@
+import { create } from 'gc-hook';
+import { dedent } from '../utils.js';
+import { fetchFiles, fetchJSModules, fetchPaths } from './_utils.js';
+import { io, stdio } from './_io.js';
+
+const type = 'webr';
+const r = new WeakMap();
+
+// REQUIRES INTEGRATION TEST
+/* c8 ignore start */
+const run = async (interpreter, code) => {
+  const { shelter, destroy, io } = r.get(interpreter);
+  const { output, result } = await shelter.captureR(dedent(code));
+  for (const { type, data } of output) io[type](data);
+  // this is a double proxy but it's OK as the consumer
+  // of the result here needs to invoke explicitly a conversion
+  // or trust the `(await p.toJs()).values` returns what's expected.
+  return create(result, destroy, { token: false });
+};
+
+export default {
+    type,
+    experimental: true,
+    module: (version = '0.3.2') =>
+        `https://cdn.jsdelivr.net/npm/webr@${version}/dist/webr.mjs`,
+    async engine(module, config) {
+        const { get } = stdio();
+        const interpreter = new module.WebR();
+        await get(interpreter.init().then(() => interpreter));
+        const shelter = await new interpreter.Shelter();
+        r.set(interpreter, {
+          module,
+          shelter,
+          destroy: shelter.destroy.bind(shelter),
+          io: io.get(interpreter),
+        });
+        if (config.files) await fetchFiles(this, interpreter, config.files);
+        if (config.fetch) await fetchPaths(this, interpreter, config.fetch);
+        if (config.js_modules) await fetchJSModules(config.js_modules);
+        return interpreter;
+    },
+    // Fallback to globally defined module fields (i.e. $xworker)
+    registerJSModule(_, name) {
+        console.warn(`Experimental interpreter: module ${name} is not supported (yet)`);
+        // TODO: as complex JS objects / modules are not allowed
+        // it's not clear how we can bind anything or import a module
+        // in a context that doesn't understand methods from JS
+        // https://docs.r-wasm.org/webr/latest/convert-js-to-r.html#constructing-r-objects-from-javascript-objects
+    },
+    run,
+    runAsync: run,
+    async runEvent(interpreter, code, event) {
+        // TODO: WebR cannot convert exoteric objects or any literal
+        // to an easy to reason about data/frame ... that convertion
+        // is reserved for the future:
+        // https://docs.r-wasm.org/webr/latest/convert-js-to-r.html#constructing-r-objects-from-javascript-objects
+        await interpreter.evalRVoid(`${code}(event)`, {
+          env: { event: { type: [ event.type ] } }
+        });
+    },
+    transform: (_, value) => {
+        console.log('transforming', value);
+        return value;
+    },
+    writeFile: () => {
+        throw new Error(`writeFile is not supported in ${type}`);
+    },
+};
+/* c8 ignore stop */

docs/toml-CkEFU7ly.js

@@ -62,5 +62,6 @@ import micropython from './interpreter/micropython.js';
 import pyodide from './interpreter/pyodide.js';
 import ruby_wasm_wasi from './interpreter/ruby-wasm-wasi.js';
 import wasmoon from './interpreter/wasmoon.js';
-for (const interpreter of [micropython, pyodide, ruby_wasm_wasi, wasmoon])
+import webr from './interpreter/webr.js';
+for (const interpreter of [micropython, pyodide, ruby_wasm_wasi, wasmoon, webr])
     register(interpreter);

docs/toml-CkEFU7ly.js.map

@@ -23,11 +23,12 @@
         "size:module": "echo module is $(cat dist/index.js | brotli | wc -c) bytes once compressed",
         "size:worker": "echo worker is $(cat esm/worker/xworker.js | brotli | wc -c) bytes once compressed",
         "ts": "rm -rf types && tsc -p .",
-        "update:interpreters": "npm run version:pyodide && npm run version:wasmoon && npm run version:micropython && npm run version:ruby-wasm-wasi && node rollup/update_versions.cjs && npm run build && npm run test",
+        "update:interpreters": "npm run version:pyodide && npm run version:wasmoon && npm run version:webr && npm run version:micropython && npm run version:ruby-wasm-wasi && node rollup/update_versions.cjs && npm run build && npm run test",
         "version:micropython": "npm view @micropython/micropython-webassembly-pyscript version>versions/micropython",
         "version:pyodide": "npm view pyodide version>versions/pyodide",
         "version:ruby-wasm-wasi": "git ls-remote --tags --refs --sort='v:refname' https://github.com/ruby/ruby.wasm.git | grep 'tags/[[:digit:]]\\.' | tail -n1 | sed 's/.*\\///'>versions/ruby-wasm-wasi",
-        "version:wasmoon": "npm view wasmoon version>versions/wasmoon"
+        "version:wasmoon": "npm view wasmoon version>versions/wasmoon",
+        "version:webr": "npm view webr version>versions/webr"
     },
     "keywords": [
         "polyscript",
@@ -89,6 +90,6 @@
         "to-json-callback": "^0.1.1"
     },
     "worker": {
-        "blob": "sha256-x9FnCN9Oz1l5i3eTcOPg2IrqbdU7VfskuTHKznW4/L0="
+        "blob": "sha256-iylBcz+1PGBPlUUA6Bb01fPXFB5kf89nm/gclV2I0Ko="
     }
 }

docs/zip-B0L2NISB.js

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width,initial-scale=1.0">
+        <title>WebR</title>
+        <link rel="stylesheet" href="style.css">
+        <script type="module" src="/dist/index.js"></script>
+    </head>
+    <body>
+      <script type="webr">
+        print_version <- function(event) {
+          if (event["type"] == "click")
+            print(R.version.string)
+        }
+      </script>
+      <button webr-click="print_version">webr version</button>
+    </body>
+</html>