mrmd-js 2.0.0 → 2.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Maxime Rivest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -56,6 +56,15 @@ const DEFAULT_FEATURES = {
  * @typedef {import('./context/interface.js').LogEntry} LogEntry
  */
 
+/**
+ * Check if a value is a Promise
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isPromise(value) {
+  return value && typeof value === 'object' && typeof value.then === 'function';
+}
+
 /**
  * Format arguments for logging
  * @param {Array<*>} args
@@ -78,6 +87,21 @@ function formatArgs(args) {
     .join(' ');
 }
 
+/**
+ * Check args for Promises and return warning message if found
+ * @param {Array<*>} args
+ * @returns {string | null}
+ */
+function checkForPromises(args) {
+  for (const arg of args) {
+    if (isPromise(arg)) {
+      return '⚠️  Promise detected - this value needs to be awaited. ' +
+             'Add "await" before the async call, or assign it to get the resolved value.';
+    }
+  }
+  return null;
+}
+
 /**
  * Create a console capture for a window context
  */
@@ -120,11 +144,23 @@ class ConsoleCapture {
     // Intercept methods
     console.log = (...args) => {
       this.#queue.push({ type: 'log', args, timestamp: Date.now() });
+      // Check for unresolved Promises and warn
+      const promiseWarning = checkForPromises(args);
+      if (promiseWarning) {
+        this.#queue.push({ type: 'warn', args: [promiseWarning], timestamp: Date.now() });
+        this.#originalConsole?.warn?.(promiseWarning);
+      }
       this.#originalConsole?.log?.(...args);
     };
 
     console.info = (...args) => {
       this.#queue.push({ type: 'info', args, timestamp: Date.now() });
+      // Check for unresolved Promises and warn
+      const promiseWarning = checkForPromises(args);
+      if (promiseWarning) {
+        this.#queue.push({ type: 'warn', args: [promiseWarning], timestamp: Date.now() });
+        this.#originalConsole?.warn?.(promiseWarning);
+      }
       this.#originalConsole?.info?.(...args);
     };
 
@@ -1510,12 +1546,12 @@ function transformForPersistence(code) {
 
     // Check for const/let keywords
     if (isWordBoundary(code, i)) {
-      if (code.slice(i, i + 5) === 'const' && isWordBoundary(code, i + 5)) {
+      if (code.slice(i, i + 5) === 'const' && isWordBoundaryAfter(code, i + 5)) {
         result += 'var';
         i += 5;
         continue;
       }
-      if (code.slice(i, i + 3) === 'let' && isWordBoundary(code, i + 3)) {
+      if (code.slice(i, i + 3) === 'let' && isWordBoundaryAfter(code, i + 3)) {
         result += 'var';
         i += 3;
         continue;
@@ -1552,15 +1588,124 @@ function isWordBoundary(code, pos) {
   return true;
 }
 
+/**
+ * Check if position after keyword is a word boundary
+ * @param {string} code
+ * @param {number} pos - Position after the keyword
+ * @returns {boolean}
+ */
+function isWordBoundaryAfter(code, pos) {
+  if (pos >= code.length) return true;
+  return !/[a-zA-Z0-9_$]/.test(code[pos]);
+}
+
 /**
  * Async Transform
  *
- * Wraps code to support top-level await.
+ * Wraps code to support top-level await and auto-awaits common async patterns.
+ * This makes JavaScript feel more linear like Python/R/Julia.
  * @module transform/async
  */
 
+
 /**
- * Check if code contains top-level await
+ * Auto-insert await before common async function calls
+ * This makes JavaScript feel more linear like Python/R
+ *
+ * @param {string} code - Source code
+ * @returns {string} Code with auto-awaits inserted
+ */
+function autoInsertAwaits(code) {
+  // Don't process if code already uses await extensively
+  // (user knows what they're doing)
+  const awaitCount = (code.match(/\bawait\b/g) || []).length;
+  const lines = code.split('\n').length;
+  if (awaitCount > lines / 2) {
+    return code;
+  }
+
+  let result = code;
+
+  // Track positions to avoid double-processing
+  // We need to be careful not to add await before already-awaited expressions
+
+  // First, temporarily replace existing awaits to protect them
+  const awaitPlaceholders = [];
+  result = result.replace(/\bawait\s+/g, (match) => {
+    const placeholder = `__AWAIT_PLACEHOLDER_${awaitPlaceholders.length}__`;
+    awaitPlaceholders.push(match);
+    return placeholder;
+  });
+
+  // Also protect strings, comments, and template literals
+  const protectedStrings = [];
+
+  // Protect comments FIRST (before strings) to handle apostrophes in comments like "doesn't"
+  result = result.replace(/\/\/[^\n]*/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+  result = result.replace(/\/\*[\s\S]*?\*\//g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Protect template literals
+  result = result.replace(/`(?:[^`\\]|\\.)*`/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Protect strings (after comments, so apostrophes in comments don't interfere)
+  result = result.replace(/"(?:[^"\\]|\\.)*"/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+  result = result.replace(/'(?:[^'\\]|\\.)*'/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Now auto-insert awaits for common patterns
+  // fetch(...) -> await fetch(...)
+  result = result.replace(/\bfetch\s*\(/g, 'await fetch(');
+
+  // import(...) -> await import(...)
+  // But not "import x from" statements
+  result = result.replace(/(?<![.\w])import\s*\(/g, 'await import(');
+
+  // .json() .text() .blob() etc on response objects
+  // These methods also return Promises, so we need to await both:
+  // response.json() -> await (await response).json()
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*json\s*\(\s*\)/g, 'await (await $1).json()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*text\s*\(\s*\)/g, 'await (await $1).text()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*blob\s*\(\s*\)/g, 'await (await $1).blob()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*arrayBuffer\s*\(\s*\)/g, 'await (await $1).arrayBuffer()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*formData\s*\(\s*\)/g, 'await (await $1).formData()');
+
+  // Restore protected content
+  for (let i = protectedStrings.length - 1; i >= 0; i--) {
+    result = result.replace(`__PROTECTED_${i}__`, protectedStrings[i]);
+  }
+
+  // Restore existing awaits
+  for (let i = awaitPlaceholders.length - 1; i >= 0; i--) {
+    result = result.replace(`__AWAIT_PLACEHOLDER_${i}__`, awaitPlaceholders[i]);
+  }
+
+  // Clean up any double awaits we might have introduced
+  result = result.replace(/\bawait\s+await\b/g, 'await');
+
+  return result;
+}
+
+/**
+ * Check if code contains top-level await (or will after auto-insertion)
  * @param {string} code
  * @returns {boolean}
  */
@@ -1569,16 +1714,17 @@ function hasTopLevelAwait(code) {
   // This is a heuristic; a proper check would need AST parsing
 
   // Remove strings, comments, and regex to avoid false positives
+  // IMPORTANT: Remove comments FIRST to handle apostrophes in comments like "doesn't"
   const cleaned = code
-    // Remove template literals (simple version)
-    .replace(/`[^`]*`/g, '')
-    // Remove strings
-    .replace(/"(?:[^"\\]|\\.)*"/g, '')
-    .replace(/'(?:[^'\\]|\\.)*'/g, '')
-    // Remove single-line comments
+    // Remove single-line comments FIRST (before strings)
     .replace(/\/\/[^\n]*/g, '')
     // Remove multi-line comments
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Remove template literals
+    .replace(/`[^`]*`/g, '')
+    // Remove strings (after comments, so apostrophes in comments don't interfere)
+    .replace(/"(?:[^"\\]|\\.)*"/g, '')
+    .replace(/'(?:[^'\\]|\\.)*'/g, '');
   let i = 0;
 
   while (i < cleaned.length) {
@@ -1650,19 +1796,50 @@ ${code}
  * @returns {string} Wrapped code that returns last expression
  */
 function wrapWithLastExpression(code) {
-  const needsAsync = hasTopLevelAwait(code);
+  // Auto-insert awaits for common async patterns (fetch, import, .json(), etc.)
+  // This makes JavaScript feel more linear like Python/R/Julia
+  const autoAwaitedCode = autoInsertAwaits(code);
 
-  // Find the last expression and make it a return value
-  // This is tricky without AST - we use eval trick instead
+  // Check if code needs async (either explicit await or auto-inserted)
+  const needsAsync = hasTopLevelAwait(autoAwaitedCode);
+
+  if (needsAsync) {
+    // For code with await, wrap in async IIFE
+    // This allows await to work at the "top level" of the user's code
+    const asyncWrappedCode = `(async () => {\n${autoAwaitedCode}\n})()`;
+
+    // Now wrap to capture the result
+    // Use indirect eval (0, eval)() to run in global scope so var declarations persist
+    const wrapped = `
+;(async function() {
+  let __result__;
+  try {
+    __result__ = await (0, eval)(${JSON.stringify(asyncWrappedCode)});
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      await (0, eval)(${JSON.stringify(asyncWrappedCode)});
+      __result__ = undefined;
+    } else {
+      throw e;
+    }
+  }
+  return __result__;
+})()`;
+    return wrapped.trim();
+  }
+
+  // No async needed - use simpler synchronous wrapper
+  // Use indirect eval (0, eval)() to run in global scope so var declarations persist
+  // Note: Still use autoAwaitedCode in case auto-awaits were added but hasTopLevelAwait missed them
   const wrapped = `
-;(${needsAsync ? 'async ' : ''}function() {
+;(function() {
   let __result__;
   try {
-    __result__ = eval(${JSON.stringify(code)});
+    __result__ = (0, eval)(${JSON.stringify(autoAwaitedCode)});
   } catch (e) {
     if (e instanceof SyntaxError) {
       // Code might be statements, not expression
-      eval(${JSON.stringify(code)});
+      (0, eval)(${JSON.stringify(autoAwaitedCode)});
       __result__ = undefined;
     } else {
       throw e;
@@ -1760,7 +1937,19 @@ class JavaScriptExecutor extends BaseExecutor {
 
     try {
       // Execute in context (pass execId for input() support)
-      const rawResult = await context.execute(wrapped, { execId: options.execId });
+      let rawResult = await context.execute(wrapped, { execId: options.execId });
+
+      // Auto-await if result is a Promise (catch cases not handled by auto-await transform)
+      if (rawResult.result && typeof rawResult.result === 'object' && typeof rawResult.result.then === 'function') {
+        try {
+          rawResult.result = await rawResult.result;
+        } catch (promiseError) {
+          // Promise rejected - treat as error
+          rawResult.error = promiseError instanceof Error ? promiseError : new Error(String(promiseError));
+          rawResult.result = undefined;
+        }
+      }
+
       const duration = performance.now() - startTime;
 
       // Format result
@@ -6198,6 +6387,143 @@ function createCssExecutor() {
   return new CssExecutor();
 }
 
+/**
+ * Mermaid Executor
+ *
+ * Executes Mermaid diagram cells by rendering them to SVG.
+ * Loads mermaid from CDN on first use and returns HTML displayData.
+ *
+ * @module execute/mermaid
+ */
+
+
+/**
+ * @typedef {import('../session/context/interface.js').ExecutionContext} ExecutionContext
+ * @typedef {import('../types/execution.js').ExecuteOptions} ExecuteOptions
+ * @typedef {import('../types/execution.js').ExecutionResult} ExecutionResult
+ * @typedef {import('../types/execution.js').DisplayData} DisplayData
+ */
+
+/** CDN URL for mermaid */
+const MERMAID_CDN = 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js';
+
+/** Counter for unique diagram IDs */
+let diagramCounter = 0;
+
+/**
+ * Load mermaid from CDN if not already loaded
+ * @returns {Promise<void>}
+ */
+async function ensureMermaidLoaded() {
+  // Check if already loaded
+  if (typeof window !== 'undefined' && window.mermaid) {
+    return;
+  }
+
+  // Load from CDN
+  return new Promise((resolve, reject) => {
+    const script = document.createElement('script');
+    script.src = MERMAID_CDN;
+    script.onload = () => {
+      // Initialize mermaid with safe defaults
+      window.mermaid.initialize({
+        startOnLoad: false,
+        theme: 'default',
+        securityLevel: 'loose', // Allow clicks/links in diagrams
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      });
+      resolve();
+    };
+    script.onerror = () => reject(new Error('Failed to load mermaid from CDN'));
+    document.head.appendChild(script);
+  });
+}
+
+/**
+ * Mermaid executor - renders Mermaid diagrams to SVG
+ */
+class MermaidExecutor extends BaseExecutor {
+  /** @type {readonly string[]} */
+  languages = ['mermaid'];
+
+  /**
+   * Execute Mermaid diagram cell
+   * @param {string} code - Mermaid diagram definition
+   * @param {ExecutionContext} context - Execution context
+   * @param {ExecuteOptions} [options] - Execution options
+   * @returns {Promise<ExecutionResult>}
+   */
+  async execute(code, context, options = {}) {
+    const startTime = performance.now();
+
+    try {
+      // Ensure mermaid is loaded
+      await ensureMermaidLoaded();
+
+      // Generate unique ID for this diagram
+      const diagramId = `mermaid-diagram-${++diagramCounter}`;
+
+      // Render the diagram
+      const { svg } = await window.mermaid.render(diagramId, code.trim());
+
+      const duration = performance.now() - startTime;
+
+      // Build display data with the rendered SVG
+      /** @type {DisplayData[]} */
+      const displayData = [
+        {
+          data: {
+            'text/html': svg,
+            'text/plain': `[Mermaid diagram rendered]`,
+          },
+          metadata: {
+            mermaid: true,
+            diagramId,
+          },
+        },
+      ];
+
+      return {
+        success: true,
+        stdout: '',
+        stderr: '',
+        result: undefined,
+        displayData,
+        assets: [],
+        executionCount: 0,
+        duration,
+      };
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+
+      // Return error as stderr with helpful message
+      return {
+        success: false,
+        stdout: '',
+        stderr: `Mermaid rendering error: ${errorMessage}`,
+        result: undefined,
+        error: {
+          type: 'MermaidError',
+          message: errorMessage,
+        },
+        displayData: [],
+        assets: [],
+        executionCount: 0,
+        duration,
+      };
+    }
+  }
+}
+
+/**
+ * Create a Mermaid executor
+ * @returns {MermaidExecutor}
+ */
+function createMermaidExecutor() {
+  return new MermaidExecutor();
+}
+
 /**
  * Execute Module
  *
@@ -6216,6 +6542,7 @@ function createDefaultExecutorRegistry() {
   registry.register(new JavaScriptExecutor());
   registry.register(new HtmlExecutor());
   registry.register(new CssExecutor());
+  registry.register(new MermaidExecutor());
   return registry;
 }
 
@@ -7542,6 +7869,7 @@ exports.HtmlRenderer = HtmlRenderer;
 exports.IframeContext = IframeContext;
 exports.JavaScriptExecutor = JavaScriptExecutor;
 exports.MainContext = MainContext;
+exports.MermaidExecutor = MermaidExecutor;
 exports.MrpRuntime = MrpRuntime;
 exports.RUNTIME_NAME = RUNTIME_NAME;
 exports.RUNTIME_VERSION = RUNTIME_VERSION;
@@ -7561,6 +7889,7 @@ exports.createHtmlRenderer = createHtmlRenderer;
 exports.createIframeContext = createIframeContext;
 exports.createJavaScriptExecutor = createJavaScriptExecutor;
 exports.createMainContext = createMainContext;
+exports.createMermaidExecutor = createMermaidExecutor;
 exports.createRuntime = createRuntime;
 exports.createSession = createSession;
 exports.createSessionManager = createSessionManager;