mrmd-js 2.0.0 → 2.0.1

package/dist/mrmd-js.iife.js

@@ -57,6 +57,15 @@ var mrmdJs = (function (exports) {
    * @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
@@ -79,6 +88,21 @@ var mrmdJs = (function (exports) {
       .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
    */
@@ -121,11 +145,23 @@ var mrmdJs = (function (exports) {
       // 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);
       };
 
@@ -1511,12 +1547,12 @@ var mrmdJs = (function (exports) {
 
       // 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;
@@ -1553,15 +1589,124 @@ var mrmdJs = (function (exports) {
     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
    */
 
+
+  /**
+   * 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
+   * Check if code contains top-level await (or will after auto-insertion)
    * @param {string} code
    * @returns {boolean}
    */
@@ -1570,16 +1715,17 @@ var mrmdJs = (function (exports) {
     // 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) {
@@ -1651,19 +1797,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;
@@ -1761,7 +1938,19 @@ ${code}
 
       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