bare-script 2.3.2 → 3.0.1

package/lib/runtimeAsync.js

@@ -4,25 +4,23 @@
 /** @module lib/runtimeAsync */
 
 import {BareScriptParserError, parseScript} from './parser.js';
-import {BareScriptRuntimeError, evaluateExpression, executeScriptHelper} from './runtime.js';
+import {BareScriptRuntimeError, evaluateExpression, scriptFunction} from './runtime.js';
 import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
+import {valueBoolean, valueCompare, valueString} from './value.js';
 import {lintScript} from './model.js';
-
-
-/* eslint-disable no-await-in-loop, require-await */
+import {urlFileRelative} from './options.js';
 
 
 /**
  * Execute a BareScript model asynchronously.
  * Use this form of the function if you have any global asynchronous functions.
  *
- * @async
- * @param {Object} script - The [BareScript model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript'}
- * @param {Object} [options = {}] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+ * @param {Object} script - The [BareScript model](./model/#var.vName='BareScript')
+ * @param {Object} [options = {}] - The [script execution options]{@link module:lib/options~ExecuteScriptOptions}
  * @returns The script result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
-export async function executeScriptAsync(script, options = {}) {
+export function executeScriptAsync(script, options = {}) {
     // Create the global variable object, if necessary
     let {globals = null} = options;
     if (globals === null) {
@@ -54,8 +52,9 @@ async function executeScriptHelperAsync(statements, options, locals) {
         const [statementKey] = Object.keys(statement);
 
         // Increment the statement counter
+        options.statementCount += 1;
         const maxStatements = options.maxStatements ?? defaultMaxStatements;
-        if (maxStatements > 0 && ++options.statementCount > maxStatements) {
+        if (maxStatements > 0 && options.statementCount > maxStatements) {
             throw new BareScriptRuntimeError(`Exceeded maximum script statements (${maxStatements})`);
         }
 
@@ -100,51 +99,20 @@ async function executeScriptHelperAsync(statements, options, locals) {
         // Function?
         } else if (statementKey === 'function') {
             if (statement.function.async) {
-                globals[statement.function.name] = async (args, fnOptions) => {
-                    const funcLocals = {};
-                    if ('args' in statement.function) {
-                        const argsLength = args.length;
-                        const funcArgsLength = statement.function.args.length;
-                        const ixArgLast = (statement.function.lastArgArray ?? null) && (funcArgsLength - 1);
-                        for (let ixArg = 0; ixArg < funcArgsLength; ixArg++) {
-                            const argName = statement.function.args[ixArg];
-                            if (ixArg < argsLength) {
-                                funcLocals[argName] = (ixArg === ixArgLast ? args.slice(ixArg) : args[ixArg]);
-                            } else {
-                                funcLocals[argName] = (ixArg === ixArgLast ? [] : null);
-                            }
-                        }
-                    }
-                    return executeScriptHelperAsync(statement.function.statements, fnOptions, funcLocals);
-                };
+                globals[statement.function.name] = (args, fnOptions) => scriptFunctionAsync(statement.function, args, fnOptions);
             } else {
-                globals[statement.function.name] = (args, fnOptions) => {
-                    const funcLocals = {};
-                    if ('args' in statement.function) {
-                        const argsLength = args.length;
-                        const funcArgsLength = statement.function.args.length;
-                        const ixArgLast = (statement.function.lastArgArray ?? null) && (funcArgsLength - 1);
-                        for (let ixArg = 0; ixArg < funcArgsLength; ixArg++) {
-                            const argName = statement.function.args[ixArg];
-                            if (ixArg < argsLength) {
-                                funcLocals[argName] = (ixArg === ixArgLast ? args.slice(ixArg) : args[ixArg]);
-                            } else {
-                                funcLocals[argName] = (ixArg === ixArgLast ? [] : null);
-                            }
-                        }
-                    }
-                    return executeScriptHelper(statement.function.statements, fnOptions, funcLocals);
-                };
+                globals[statement.function.name] = (args, fnOptions) => scriptFunction(statement.function, args, fnOptions);
             }
 
         // Include?
         } else if (statementKey === 'include') {
             // Fetch the include script text
+            const urlFn = options.urlFn ?? null;
             const includeURLs = statement.include.includes.map(({url, system = false}) => {
-                if (system && 'systemPrefix' in options && isRelativeURL(url)) {
-                    return `${options.systemPrefix}${url}`;
+                if (system && 'systemPrefix' in options) {
+                    return urlFileRelative(options.systemPrefix, url);
                 }
-                return 'urlFn' in options ? options.urlFn(url) : url;
+                return urlFn !== null ? urlFn(url) : url;
             });
             const responses = await Promise.all(includeURLs.map(async (url) => {
                 try {
@@ -194,7 +162,7 @@ async function executeScriptHelperAsync(statements, options, locals) {
 
                 // Execute the include script
                 const includeOptions = {...options};
-                includeOptions.urlFn = (url) => (isRelativeURL(url) ? `${getBaseURL(includeURL)}${url}` : url);
+                includeOptions.urlFn = (url) => urlFileRelative(includeURL, url);
                 await executeScriptHelperAsync(scriptModel.statements, includeOptions, null);
             }
         }
@@ -204,17 +172,23 @@ async function executeScriptHelperAsync(statements, options, locals) {
 }
 
 
-// Test if a URL is relative
-function isRelativeURL(url) {
-    return !rNotRelativeURL.test(url);
-}
-
-const rNotRelativeURL = /^(?:[a-z]+:|\/|\?|#)/;
-
-
-// Get a URL's base URL
-function getBaseURL(url) {
-    return url.slice(0, url.lastIndexOf('/') + 1);
+// Runtime script async function implementation
+function scriptFunctionAsync(function_, args, options) {
+    const funcLocals = {};
+    if ('args' in function_) {
+        const argsLength = args.length;
+        const funcArgsLength = function_.args.length;
+        const ixArgLast = (function_.lastArgArray ?? null) && (funcArgsLength - 1);
+        for (let ixArg = 0; ixArg < funcArgsLength; ixArg++) {
+            const argName = function_.args[ixArg];
+            if (ixArg < argsLength) {
+                funcLocals[argName] = (ixArg === ixArgLast ? args.slice(ixArg) : args[ixArg]);
+            } else {
+                funcLocals[argName] = (ixArg === ixArgLast ? [] : null);
+            }
+        }
+    }
+    return executeScriptHelperAsync(function_.statements, options, funcLocals);
 }
 
 
@@ -223,11 +197,10 @@ function getBaseURL(url) {
  * Use this form of the function if you have any asynchronous functions.
  *
  * @async
- * @param {Object} expr - The [expression model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='Expression'}
- * @param {?Object} [options = null] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+ * @param {Object} expr - The [expression model](./model/#var.vName='Expression')
+ * @param {?Object} [options = null] - The [script execution options]{@link module:lib/options~ExecuteScriptOptions}
  * @param {?Object} [locals = null] - The local variables
- * @param {boolean} [builtins = true] - If true, include the
- *     [built-in expression functions]{@link https://craigahobbs.github.io/bare-script/library/expression.html}
+ * @param {boolean} [builtins = true] - If true, include the [built-in expression functions](./library/expression.html)
  * @returns The expression result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
@@ -289,7 +262,6 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         // Global/local function?
         let funcValue = (locals !== null ? locals[funcName] : undefined);
         if (typeof funcValue === 'undefined') {
-            /* c8 ignore next */
             funcValue = (globals !== null ? globals[funcName] : undefined);
             if (typeof funcValue === 'undefined') {
                 funcValue = (builtins ? expressionFunctions[funcName] : null) ?? null;
@@ -321,40 +293,90 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         const binOp = expr.binary.op;
         const leftValue = await evaluateExpressionAsync(expr.binary.left, options, locals, builtins);
 
-        // Short-circuiting binary operators - evaluate right expression only if necessary
+        // Short-circuiting "and" binary operator
         if (binOp === '&&') {
-            return leftValue && evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
+            if (!valueBoolean(leftValue)) {
+                return leftValue;
+            }
+            return evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
+
+        // Short-circuiting "or" binary operator
         } else if (binOp === '||') {
-            return leftValue || evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
+            if (valueBoolean(leftValue)) {
+                return leftValue;
+            }
+            return evaluateExpressionAsync (expr.binary.right, options, locals, builtins);
         }
 
         // Non-short-circuiting binary operators
         const rightValue = await evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
-        if (binOp === '**') {
-            return leftValue ** rightValue;
+        if (binOp === '+') {
+            // number + number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue + rightValue;
+
+            // string + string
+            } else if (typeof leftValue === 'string' && typeof rightValue === 'string') {
+                return leftValue + rightValue;
+
+            // string + <any>
+            } else if (typeof leftValue === 'string') {
+                return leftValue + valueString(rightValue);
+            } else if (typeof rightValue === 'string') {
+                return valueString(leftValue) + rightValue;
+
+            // datetime + number
+            } else if (leftValue instanceof Date && typeof rightValue === 'number') {
+                return new Date(leftValue.getTime() + rightValue);
+            } else if (typeof leftValue === 'number' && rightValue instanceof Date) {
+                return new Date(leftValue + rightValue.getTime());
+            }
+        } else if (binOp === '-') {
+            // number - number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue - rightValue;
+
+            // datetime - datetime
+            } else if (leftValue instanceof Date && rightValue instanceof Date) {
+                return leftValue - rightValue;
+            }
         } else if (binOp === '*') {
-            return leftValue * rightValue;
+            // number * number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue * rightValue;
+            }
         } else if (binOp === '/') {
-            return leftValue / rightValue;
-        } else if (binOp === '%') {
-            return leftValue % rightValue;
-        } else if (binOp === '+') {
-            return leftValue + rightValue;
-        } else if (binOp === '-') {
-            return leftValue - rightValue;
+            // number / number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue / rightValue;
+            }
+        } else if (binOp === '==') {
+            return valueCompare(leftValue, rightValue) === 0;
+        } else if (binOp === '!=') {
+            return valueCompare(leftValue, rightValue) !== 0;
         } else if (binOp === '<=') {
-            return leftValue <= rightValue;
+            return valueCompare(leftValue, rightValue) <= 0;
         } else if (binOp === '<') {
-            return leftValue < rightValue;
+            return valueCompare(leftValue, rightValue) < 0;
         } else if (binOp === '>=') {
-            return leftValue >= rightValue;
+            return valueCompare(leftValue, rightValue) >= 0;
         } else if (binOp === '>') {
-            return leftValue > rightValue;
-        } else if (binOp === '==') {
-            return leftValue === rightValue;
+            return valueCompare(leftValue, rightValue) > 0;
+        } else if (binOp === '%') {
+            // number % number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue % rightValue;
+            }
+        } else {
+            // binOp === '**'
+            // number ** number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue ** rightValue;
+            }
         }
-        // else if (binOp === '!=')
-        return leftValue !== rightValue;
+
+        // Invalid operation values
+        return null;
     }
 
     // Unary expression
@@ -362,10 +384,13 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         const unaryOp = expr.unary.op;
         const value = await evaluateExpressionAsync(expr.unary.expr, options, locals, builtins);
         if (unaryOp === '!') {
-            return !value;
+            return !valueBoolean(value);
+        } else if (unaryOp === '-' && typeof value === 'number') {
+            return -value;
         }
-        // else if (unaryOp === '-')
-        return -value;
+
+        // Invalid operation value
+        return null;
     }
 
     // Expression group

package/lib/value.js

@@ -0,0 +1,287 @@
+// Licensed under the MIT License
+// https://github.com/craigahobbs/bare-script/blob/main/LICENSE
+
+
+/**
+ * Get a value's type string
+ *
+ * @param value - The value
+ * @returns {string} The type string ('array', 'boolean', 'datetime', 'function', 'null', 'number', 'object', 'regex', 'string')
+ * @ignore
+ */
+export function valueType(value) {
+    const type = typeof value;
+    if (value === null || type === 'undefined') {
+        return 'null';
+    } else if (type === 'string') {
+        return 'string';
+    } else if (type === 'boolean') {
+        return 'boolean';
+    } else if (type === 'number') {
+        return 'number';
+    } else if (value instanceof Date) {
+        return 'datetime';
+    } else if (Array.isArray(value)) {
+        return 'array';
+    } else if (value instanceof RegExp) {
+        return 'regex';
+    } else if (type === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        return 'object';
+    } else if (type === 'function') {
+        return 'function';
+    }
+
+    // Unknown value type
+    return null;
+}
+
+
+/**
+ * Get a value's string representation
+ *
+ * @param value - The value
+ * @returns {string} The value as a string
+ * @ignore
+ */
+export function valueString(value) {
+    const type = typeof value;
+    if (value === null || type === 'undefined') {
+        return 'null';
+    } else if (type === 'string') {
+        return value;
+    } else if (type === 'boolean') {
+        return value ? 'true' : 'false';
+    } else if (type === 'number') {
+        return `${value}`;
+    } else if (value instanceof Date) {
+        const year = value.getFullYear();
+        const month = value.getMonth() + 1;
+        const monthStr = `${month < 10 ? '0' : ''}${month}`;
+        const day = value.getDate();
+        const dayStr = `${day < 10 ? '0' : ''}${day}`;
+        const hour = value.getHours();
+        const hourStr = `${hour < 10 ? '0' : ''}${hour}`;
+        const minute = value.getMinutes();
+        const minuteStr = `${minute < 10 ? '0' : ''}${minute}`;
+        const second = value.getSeconds();
+        const secondStr = `${second < 10 ? '0' : ''}${second}`;
+        const millisecond = value.getMilliseconds();
+        const millisecondStr = millisecond === 0 ? '' : `.${millisecond < 100 ? '0' : ''}${millisecond < 10 ? '0' : ''}${millisecond}`;
+        const tzOffset = value.getTimezoneOffset();
+        /* c8 ignore next */
+        const tzSign = tzOffset < 0 ? '-' : '+';
+        const tzHour = Math.floor(Math.abs(tzOffset) / 60);
+        /* c8 ignore next */
+        const tzHourStr = `${tzHour < 10 ? '0' : ''}${tzHour}`;
+        const tzMinute = Math.abs(tzOffset) - tzHour * 60;
+        /* c8 ignore next */
+        const tzMinuteStr = `${tzMinute < 10 ? '0' : ''}${tzMinute}`;
+        return `${year}-${monthStr}-${dayStr}T${hourStr}:${minuteStr}:${secondStr}${millisecondStr}${tzSign}${tzHourStr}:${tzMinuteStr}`;
+    } else if (Array.isArray(value)) {
+        return valueJSON(value);
+    } else if (value instanceof RegExp) {
+        return '<regex>';
+    } else if (type === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        return valueJSON(value);
+    } else if (type === 'function') {
+        return '<function>';
+    }
+
+    // Unknown value type
+    return '<unknown>';
+}
+
+
+/**
+ * Get a value's JSON string representation
+ *
+ * @param value - The value
+ * @param {number} indent - The JSON indent
+ * @returns {string} The value as a JSON string
+ * @ignore
+ */
+export function valueJSON(value, indent = null) {
+    return JSON.stringify(valueJSONSort(value), null, indent);
+}
+
+
+function valueJSONSort(value) {
+    const type = typeof value;
+    if (value === null || type === 'undefined' || type === 'string' || type === 'boolean' || type === 'number') {
+        return value;
+    } else if (value instanceof Date) {
+        return valueString(value);
+    } else if (Array.isArray(value)) {
+        return value.map(valueJSONSort);
+    } else if (type === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+        const valueCopy = {};
+        for (const valueKey of Object.keys(value).sort()) {
+            valueCopy[valueKey] = valueJSONSort(value[valueKey]);
+        }
+        return valueCopy;
+    }
+
+    // Everything else is null
+    return null;
+}
+
+
+/**
+ * Interpret the value as a boolean
+ *
+ * @param value - The value
+ * @returns {boolean} The value as a boolean
+ * @ignore
+ */
+export function valueBoolean(value) {
+    const type = typeof value;
+    if (value === null || type === 'undefined') {
+        return false;
+    } else if (type === 'string') {
+        return value !== '';
+    } else if (type === 'boolean') {
+        return value;
+    } else if (type === 'number') {
+        return value !== 0;
+    } else if (value instanceof Date) {
+        return true;
+    } else if (Array.isArray(value)) {
+        return value.length !== 0;
+    }
+
+    // Everything else is true
+    return true;
+}
+
+
+/**
+ * Test if one value is the same object as another
+ *
+ * @param value1 - The first value
+ * @param value2 - The second value
+ * @returns {boolean} true if values are the same object, false otherwise
+ * @ignore
+ */
+export function valueIs(value1, value2) {
+    if (value1 instanceof RegExp && value2 instanceof RegExp) {
+        return value1 === value2 || value1.source === value2.source;
+    }
+    return value1 === value2;
+}
+
+
+/**
+ * Compare two values
+ *
+ * @param left - The left value
+ * @param right - The right value
+ * @returns {number} -1 if the left value is less than the right value, 0 if equal, and 1 if greater than
+ * @ignore
+ */
+export function valueCompare(left, right) {
+    const leftType = typeof left;
+    const rightType = typeof right;
+    if (left === null || leftType === 'undefined') {
+        return right === null || rightType === 'undefined' ? 0 : -1;
+    } else if (right === null || rightType === 'undefined') {
+        return 1;
+    } else if (leftType === 'string' && rightType === 'string') {
+        return left < right ? -1 : (left === right ? 0 : 1);
+    } else if (leftType === 'number' && rightType === 'number') {
+        return left < right ? -1 : (left === right ? 0 : 1);
+    } else if (leftType === 'boolean' && rightType === 'boolean') {
+        return left < right ? -1 : (left === right ? 0 : 1);
+    } else if (left instanceof Date && right instanceof Date) {
+        return left < right ? -1 : (left > right ? 1 : 0);
+    } else if (Array.isArray(left) && Array.isArray(right)) {
+        const ixEnd = Math.min(left.length, right.length);
+        for (let ix = 0; ix < ixEnd; ix++) {
+            const itemCompare = valueCompare(left[ix], right[ix]);
+            if (itemCompare !== 0) {
+                return itemCompare;
+            }
+        }
+        return left.length < right.length ? -1 : (left.length === right.length ? 0 : 1);
+    }
+
+    // Invalid comparison - compare by type name
+    const leftValueType = valueType(left) ?? 'unknown';
+    const rightValueType = valueType(right) ?? 'unknown';
+    return leftValueType < rightValueType ? -1 : (leftValueType === rightValueType ? 0 : 1);
+}
+
+
+/**
+ * Round a number
+ *
+ * @param {number} value - The number to round
+ * @param {number} digits - The number of digits of precision
+ * @returns {number} The rounded number
+ * @ignore
+ */
+export function valueRoundNumber(value, digits) {
+    const multiplier = 10 ** digits;
+    return Math.round(value * multiplier) / multiplier;
+}
+
+
+/**
+ * Parse a number string
+ *
+ * @param {string} text - The string to parse as a number
+ * @returns {number|null}: A number value or null if parsing fails
+ * @ignore
+ */
+export function valueParseNumber(text) {
+    if (!rNumber.test(text)) {
+        return null;
+    }
+    return Number.parseFloat(text);
+}
+
+
+const rNumber = /^\s*[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?\s*$/;
+
+
+/**
+ * Parse an integer string
+ *
+ * @param {string} text - The string to parse as an integer
+ * @param {number} radix - The integer's radix (2 - 36). Default is 10.
+ * @returns {number|null}: A number value or null if parsing fails
+ * @ignore
+ */
+export function valueParseInteger(text, radix = 10) {
+    if (!rInteger.test(text)) {
+        return null;
+    }
+    return Number.parseInt(text, radix);
+}
+
+
+const rInteger = /^\s*[-+]?\d+\s*$/;
+
+
+/**
+ * Parse a datetime string
+ *
+ * @param {string} text - The string to parse as a datetime
+ * @returns {Date|null} A datetime value or null if parsing fails
+ * @ignore
+ */
+export function valueParseDatetime(text) {
+    const mDate = text.match(rDate);
+    if (mDate !== null) {
+        const year = Number.parseInt(mDate.groups.year, 10);
+        const month = Number.parseInt(mDate.groups.month, 10);
+        const day = Number.parseInt(mDate.groups.day, 10);
+        return new Date(year, month - 1, day);
+    } else if (rDatetime.test(text)) {
+        return new Date(text);
+    }
+    return null;
+}
+
+
+const rDate = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/;
+const rDatetime = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:Z|[+-]\d{2}:\d{2})$/;

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "bare-script",
-    "version": "2.3.2",
+    "version": "3.0.1",
     "description": "BareScript; a lightweight scripting and expression language",
     "keywords": [
         "expression",
@@ -31,7 +31,7 @@
     },
     "devDependencies": {
         "c8": "~9.1",
-        "eslint": "~8.56",
+        "eslint": "~8.57",
         "jsdoc": "~4.0"
     }
 }