Merge pull request #7803 from processing/rest-types

Rest types

Author: davepagurek

docs/parameterData.json

@@ -1427,7 +1427,7 @@
     "createVector": {
       "overloads": [
         [
-          null
+          "...Number[]"
         ]
       ]
     },

src/core/friendly_errors/param_validator.js

@@ -226,9 +226,14 @@ function validateParams(p5, fn, lifecycles) {
       const isOptional = param?.endsWith('?');
       param = param?.replace(/\?$/, '');
 
-      let schema = generateTypeSchema(param);
+      const isRest = param?.startsWith('...') && param?.endsWith('[]');
+      param = param?.replace(/^\.\.\.(.+)\[\]$/, '$1');
 
-      return isOptional ? schema.optional() : schema;
+      let schema = generateTypeSchema(param);
+      if (isOptional) {
+        schema = schema.optional();
+      }
+      return { schema, rest: isRest };
     };
 
     // Note that in Zod, `optional()` only checks for undefined, not the absence
@@ -262,14 +267,22 @@ function validateParams(p5, fn, lifecycles) {
     const overloadSchemas = overloads.flatMap(overload => {
       const combinations = generateOverloadCombinations(overload);
 
-      return combinations.map(combo =>
-        z.tuple(
-          combo
-            .map(p => generateParamSchema(p))
-            // For now, ignore schemas that cannot be mapped to a defined type
-            .filter(schema => schema !== undefined)
-        )
-      );
+      return combinations.map(combo => {
+        const params = combo
+          .map(p => generateParamSchema(p))
+          .filter(s => s.schema !== undefined);
+
+        let rest;
+        if (params.at(-1)?.rest) {
+          rest = params.pop();
+        }
+
+        let combined = z.tuple(params.map(s => s.schema));
+        if (rest) {
+          combined = combined.rest(rest.schema);
+        }
+        return combined;
+      });
     });
 
     return overloadSchemas.length === 1
@@ -504,7 +517,7 @@ function validateParams(p5, fn, lifecycles) {
     // theoretically allowed to stay undefined and valid, it is likely that the
     // user intended to call the function with non-undefined arguments. Skip
     // regular workflow and return a friendly error message right away.
-    if (Array.isArray(args) && args.every(arg => arg === undefined)) {
+    if (Array.isArray(args) && args.length > 0 && args.every(arg => arg === undefined)) {
       const undefinedErrorMessage = `🌸 p5.js says: All arguments for ${func}() are undefined. There is likely an error in the code.`;
 
       return {

src/math/math.js

@@ -34,7 +34,7 @@ function math(p5, fn) {
    * <a href="#/p5.Vector">p5.Vector</a> class.
    *
    * @method createVector
-   * @param {...Number} components Components of the vector.
+   * @param {...Number} x Zero or more numbers, representing each component of the vector.
    * @return {p5.Vector} new <a href="#/p5.Vector">p5.Vector</a> object.
    *
    * @example

test/unit/core/param_errors.js

@@ -253,6 +253,29 @@ suite('Validate Params', function () {
       ];
       const result = mockP5Prototype.validate('p5.paletteLerp', [colorStops, 0.5]);
       assert.isTrue(result.success);
-    })
-  })
+    });
+  });
+
+  suite('validateParams: rest arguments', function () {
+    test('createVector(): works with no args', function() {
+      const result = mockP5Prototype.validate('p5.createVector', []);
+      assert.isTrue(result.success);
+    });
+    test('createVector(): works with one number', function() {
+      const result = mockP5Prototype.validate('p5.createVector', [1]);
+      assert.isTrue(result.success);
+    });
+    test('createVector(): works with many numbers', function() {
+      const result = mockP5Prototype.validate('p5.createVector', [1, 2, 3, 4]);
+      assert.isTrue(result.success);
+    });
+    test('createVector(): fails with a non-number', function() {
+      const result = mockP5Prototype.validate('p5.createVector', ['1']);
+      assert.isFalse(result.success);
+    });
+    test('createVector(): fails with any non-number', function() {
+      const result = mockP5Prototype.validate('p5.createVector', [1, 2, '3', 4]);
+      assert.isFalse(result.success);
+    });
+  });
 });

utils/convert.mjs

@@ -92,6 +92,8 @@ function typeObject(node) {
     return { type: signature };
   } else if (node.type === 'ArrayType') {
     return { type: `[${node.elements.map(e => typeObject(e).type).join(', ')}]` };
+  } else if (node.type === 'RestType') {
+    return { type: typeObject(node.expression).type, rest: true };
   } else {
     // TODO
     // - handle record types
@@ -518,19 +520,22 @@ function cleanUpClassItems(data) {
 
     const processOverload = overload => {
       if (overload.params) {
-        return Object.values(overload.params).map(param => processOptionalParam(param));
+        return Object.values(overload.params).map(param => processParam(param));
       }
       return overload;
     }
 
     // To simplify `parameterData.json`, instead of having a separate field for
     // optional parameters, we'll add a ? to the end of parameter type to
     // indicate that it's optional.
-    const processOptionalParam = param => {
+    const processParam = param => {
       let type = param.type;
       if (param.optional) {
         type += '?';
       }
+      if (param.rest) {
+        type = `...${type}[]`;
+      }
       return type;
     }
 

utils/helper.mjs

@@ -392,6 +392,8 @@ export function generateTypeFromTag(param) {
         const innerTypeStrs = param.type.elements.map(e => generateTypeFromTag({ type: e }));
         return `[${innerTypeStrs.join(', ')}]`;
       }
+      case 'RestType':
+        return `${generateTypeFromTag({ type: param.type.expression })}[]`;
       default:
         return 'any';
     }
@@ -420,6 +422,7 @@ export function generateTypeFromTag(param) {
     if (!param) return 'any';
 
     let type = param.type;
+    let prefix = '';
     const isOptional = param.type?.type === 'OptionalType';
     if (typeof type === 'string') {
       type = normalizeTypeName(type);
@@ -429,7 +432,11 @@ export function generateTypeFromTag(param) {
       type = 'any';
     }
 
-    return `${param.name}${isOptional ? '?' : ''}: ${type}`;
+    if (param.type?.type === 'RestType') {
+      prefix = '...';
+    }
+
+    return `${prefix}${param.name}${isOptional ? '?' : ''}: ${type}`;
   }
 
   export function generateFunctionDeclaration(funcDoc) {