bare-script 3.0.5 → 3.0.7

package/lib/runtime.js

@@ -3,8 +3,8 @@
 
 /** @module lib/runtime */
 
+import {ValueArgsError, valueBoolean, valueCompare, valueString} from './value.js';
 import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
-import {valueBoolean, valueCompare, valueString} from './value.js';
 
 
 /**
@@ -211,6 +211,9 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
                 if (options !== null && 'logFn' in options && options.debug) {
                     options.logFn(`BareScript: Function "${funcName}" failed with error: ${error.message}`);
                 }
+                if (error instanceof ValueArgsError) {
+                    return error.returnValue;
+                }
                 return null;
             }
         }

package/lib/runtimeAsync.js

@@ -5,8 +5,8 @@
 
 import {BareScriptParserError, parseScript} from './parser.js';
 import {BareScriptRuntimeError, evaluateExpression, scriptFunction} from './runtime.js';
+import {ValueArgsError, valueBoolean, valueCompare, valueString} from './value.js';
 import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
-import {valueBoolean, valueCompare, valueString} from './value.js';
 import {lintScript} from './model.js';
 import {urlFileRelative} from './options.js';
 
@@ -281,6 +281,9 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
                 if (options !== null && 'logFn' in options && options.debug) {
                     options.logFn(`BareScript: Function "${funcName}" failed with error: ${error.message}`);
                 }
+                if (error instanceof ValueArgsError) {
+                    return error.returnValue;
+                }
                 return null;
             }
         }

package/lib/value.js

@@ -1,6 +1,9 @@
 // Licensed under the MIT License
 // https://github.com/craigahobbs/bare-script/blob/main/LICENSE
 
+import {parseSchemaMarkdown} from 'schema-markdown/lib/parser.js';
+import {validateType} from 'schema-markdown/lib/schema.js';
+
 
 /**
  * Get a value's type string
@@ -205,6 +208,221 @@ export function valueCompare(left, right) {
 }
 
 
+//
+// Function arguments validation
+//
+
+
+/**
+ * Validate a function's arguments
+ *
+ * @param {Object[]} fnArgs - The function arguments model
+ * @param {Array} args - The function arguments
+ * @param {*} [errorReturnValue = null] - The function's return value on error
+ * @returns {Array} The validated function arguments
+ * @ignore
+ */
+export function valueArgsValidate(fnArgs, args, errorReturnValue = null) {
+    const fnArgsLength = fnArgs.length;
+    for (let ix = 0; ix < fnArgsLength; ix++) {
+        const fnArg = fnArgs[ix];
+        const {'type': argType = null, 'default': argDefault = null, lastArgArray = false} = fnArg;
+
+        // Missing argument?
+        if (ix >= args.length) {
+            // Last argument array?
+            if (lastArgArray) {
+                args.push([]);
+                continue;
+            }
+
+            // Argument default?
+            if (argDefault !== null) {
+                args.push(argDefault);
+                continue;
+            }
+
+            // Boolean argument?
+            if (argType === 'boolean') {
+                args.push(false);
+                continue;
+            }
+
+            // Argument nullable?
+            if (argType === null || fnArg.nullable) {
+                args.push(null);
+                continue;
+            }
+
+            // Invalid null value...
+            throw new ValueArgsError(fnArg.name, null, errorReturnValue);
+        }
+
+        // Last arg array?
+        if (lastArgArray) {
+            args.push(args.splice(ix));
+            continue;
+        }
+
+        // Any type OK?
+        if (argType === null) {
+            continue;
+        }
+
+        // Boolean argument?
+        const argValue = args[ix];
+        if (argType === 'boolean') {
+            args[ix] = valueBoolean(argValue);
+            continue;
+        }
+
+        // Null value?
+        const argValueType = typeof argValue;
+        if (argValue === null || argValueType === 'undefined') {
+            // Argument nullable?
+            if (!fnArg.nullable) {
+                throw new ValueArgsError(fnArg.name, argValue, errorReturnValue);
+            }
+            continue;
+        }
+
+        // Invalid value?
+        if ((argType === 'number' && argValueType !== 'number') ||
+            (argType === 'string' && argValueType !== 'string') ||
+            (argType === 'array' && !Array.isArray(argValue)) ||
+            (argType === 'object' && !(argValueType === 'object' && Object.getPrototypeOf(argValue) === Object.prototype)) ||
+            (argType === 'datetime' && !(argValue instanceof Date)) ||
+            (argType === 'regex' && !(argValue instanceof RegExp)) ||
+            (argType === 'function' && argValueType !== 'function')
+           ) {
+            throw new ValueArgsError(fnArg.name, argValue, errorReturnValue);
+        }
+
+        // Number constraints
+        if (argType === 'number') {
+            const {integer = false, lt = null, lte = null, gt = null, gte = null} = fnArg;
+            if ((integer && Math.floor(argValue) !== argValue) ||
+                (lt !== null && !(argValue < lt)) ||
+                (lte !== null && !(argValue <= lte)) ||
+                (gt !== null && !(argValue > gt)) ||
+                (gte !== null && !(argValue >= gte))) {
+                throw new ValueArgsError(fnArg.name, argValue, errorReturnValue);
+            }
+        }
+    }
+
+    // Extra arguments?
+    if (args.length > fnArgsLength) {
+        args.splice(fnArgsLength);
+    }
+
+    return args;
+}
+
+
+/**
+ * A function arguments validation error
+ *
+ * @extends {Error}
+ * @property {*} returnValue - The function's error return value
+ * @ignore
+ */
+export class ValueArgsError extends Error {
+    /**
+     * Create a BareScript runtime error
+     *
+     * @param {string} argName - The function argument name
+     * @param {*} argValue - The function argument value
+     * @param {*} [returnValue = null] - The function's error return value
+     */
+    constructor(argName, argValue, returnValue = null) {
+        const message = `Invalid "${argName}" argument value, ${valueJSON(argValue)}`;
+        super(message);
+        this.name = this.constructor.name;
+        this.returnValue = returnValue;
+    }
+}
+
+
+/**
+ * Validate a function arguments model
+ *
+ * @param {Object[]} fnArgs - The function arguments model
+ * @returns {Object[]} The validated function arguments model
+ * @ignore
+ */
+export function valueArgsModel(fnArgs) {
+    validateType(valueArgsTypes, 'FunctionArguments', fnArgs);
+
+    // Use nullable instead of default-null
+    for (const fnArg of fnArgs) {
+        if (fnArg.default === null) {
+            throw Error(`Argument "${fnArg.name}" has default value of null - use nullable instead`);
+        }
+    }
+
+    return fnArgs;
+}
+
+
+// Function arguments type model
+const valueArgsTypes = parseSchemaMarkdown(`\
+# A function arguments model
+typedef FunctionArgument[len > 0] FunctionArguments
+
+
+# A function argument model
+struct FunctionArgument
+
+    # The argument name
+    string name
+
+    # The argument type
+    optional FunctionArgumentType type
+
+    # If true, the argument may be null
+    optional bool nullable
+
+    # The default argument value
+    optional object default
+
+    # If true, this argument is the array of remaining arguments
+    optional object lastArgArray
+
+    # If true, the number argument must be an integer
+    optional bool integer
+
+    # The number argument must be less-than
+    optional object lt
+
+    # The number argument must be less-than-or-equal-to
+    optional object lte
+
+    # The number argument must be greater-than
+    optional object gt
+
+    # The number argument must be greater-than-or-equal-to
+    optional object gte
+
+
+# The function argument types
+enum FunctionArgumentType
+    array
+    boolean
+    datetime
+    function
+    number
+    object
+    regex
+    string
+`);
+
+
+//
+// Number value functions
+//
+
+
 /**
  * Round a number
  *
@@ -256,6 +474,11 @@ export function valueParseInteger(text, radix = 10) {
 const rInteger = /^\s*[-+]?\d+\s*$/;
 
 
+//
+// Datetime value functions
+//
+
+
 /**
  * Parse a datetime string
  *

package/package.json

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