bare-script 3.8.4 → 3.8.6

package/lib/include/dataTable.bare

@@ -127,7 +127,7 @@ function dataTableMarkdown(data, model):
             value = objectGet(row, field)
             valueType = systemType(value)
             if valueType == 'string':
-                valueFormat = value
+                valueFormat = stringTrim(value)
             elif valueType == 'number':
                 valueFormat = numberToFixed(value, precisionNumber, precisionTrim)
             elif valueType == 'datetime':
@@ -135,6 +135,12 @@ function dataTableMarkdown(data, model):
             else:
                 valueFormat = stringNew(value)
             endif
+
+            # Eliminate value string newlines
+            valueFormat = regexReplace(dataTableMarkdownRegexMultipleNewline, valueFormat, '<br><br>')
+            valueFormat = regexReplace(dataTableMarkdownRegexSingleNewline, valueFormat, ' ')
+
+            # Set the field value string
             objectSet(rowFormat, field, valueFormat)
 
             # Update the field width
@@ -190,6 +196,11 @@ function dataTableMarkdown(data, model):
 endfunction
 
 
+# Field value newline replacement regular expressions
+dataTableMarkdownRegexMultipleNewline = regexNew('\r?\n(?:\r?\n)+')
+dataTableMarkdownRegexSingleNewline = regexNew('\r?\n')
+
+
 # Helper to generate the Markdown field text
 function dataTableMarkdownField(value, width, align, fill):
     spaces = width - stringLength(value)

package/lib/model.js

@@ -565,37 +565,43 @@ function isPointlessExpression(expr) {
 
 
 // Helper function to determine if a statement requires async
-function isAsyncStatement(statement, globals, isAsync) {
+function isAsyncStatement(statement, globals, isAsyncScope) {
     const [statementKey] = Object.keys(statement);
     if (statementKey === 'expr') {
-        return isAsyncExpression(statement.expr.expr, globals, isAsync);
+        return isAsyncExpression(statement.expr.expr, globals, isAsyncScope);
     } else if (statementKey === 'jump') {
-        return 'expr' in statement.jump ? isAsyncExpression(statement.jump.expr, globals, isAsync) : false;
+        return 'expr' in statement.jump ? isAsyncExpression(statement.jump.expr, globals, isAsyncScope) : false;
     } else if (statementKey === 'return') {
-        return 'expr' in statement.return ? isAsyncExpression(statement.return.expr, globals, isAsync) : false;
+        return 'expr' in statement.return ? isAsyncExpression(statement.return.expr, globals, isAsyncScope) : false;
     }
     return false;
 }
 
 
 // Helper function to determine if an expression statement requires async
-function isAsyncExpression(expr, globals, isAsync) {
+function isAsyncExpression(expr, globals, isAsyncScope) {
     const [exprKey] = Object.keys(expr);
     if (exprKey === 'function') {
-        // Global function not exist? Assume its OK for the scope
-        const funcValue = globals[expr.function.name] ?? null;
-        if (funcValue === null) {
-            return isAsync;
+        // Builtin function?
+        const funcName = expr.function.name;
+        if (builtinGlobals.has(funcName)) {
+            return false;
         }
 
-        // Is function async?
-        return typeof funcValue === 'function' && funcValue.constructor.name === 'AsyncFunction';
+        // Is function async? Assume unknown OK for the scope
+        let isAsync = isAsyncScope;
+        const funcValue = globals[funcName] ?? null;
+        if (typeof funcValue === 'function') {
+            isAsync = (funcValue.constructor.name === 'AsyncFunction') ||
+                ('args' in expr.function && expr.function.args.some((argExpr) => isAsyncExpression(argExpr, globals, isAsyncScope)));
+        }
+        return isAsync;
     } else if (exprKey === 'binary') {
-        return isAsyncExpression(expr.binary.left, globals, isAsync) || isAsyncExpression(expr.binary.right, globals, isAsync);
+        return isAsyncExpression(expr.binary.left, globals, isAsyncScope) || isAsyncExpression(expr.binary.right, globals, isAsyncScope);
     } else if (exprKey === 'unary') {
-        return isAsyncExpression(expr.unary.expr, globals, isAsync);
+        return isAsyncExpression(expr.unary.expr, globals, isAsyncScope);
     } else if (exprKey === 'group') {
-        return isAsyncExpression(expr.group, globals, isAsync);
+        return isAsyncExpression(expr.group, globals, isAsyncScope);
     }
     return false;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "bare-script",
-    "version": "3.8.4",
+    "version": "3.8.6",
     "description": "BareScript; a lightweight scripting and expression language",
     "keywords": [
         "expression",