mrmd-js 2.0.0 → 2.0.1

package/dist/index.js

@@ -54,6 +54,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
@@ -76,6 +85,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
  */
@@ -118,11 +142,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);
     };
 
@@ -1508,12 +1544,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;
@@ -1550,15 +1586,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
  */
 
+
+/**
+ * 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}
  */
@@ -1567,16 +1712,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) {
@@ -1648,19 +1794,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;
@@ -1758,7 +1935,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