p5 2.0.0 → 2.0.2

package/src/core/README.md

@@ -1,91 +0,0 @@
-# p5.js Core
-
-This folder contains the core functionality of p5.js, including the init and main files, environment, constants, the friendly error system, and the graphics pipeline (with the exception of 3D/WebGL). [Here is a diagram](
-https://sketchboard.me/zBOkvPuQisyA#/) that outlines how the main graphics-related classes inherit from and extend one another. There is still more to be done to document this pipeline more clearly.
-
-![class diagram, interactive version viewable in above link](../../contributor_docs/images/p5-graphics-diagram.png)
-
-## [init.js](./init.js)
-
-The `init.js` module initializes a new `p5` object in either global mode, instance mode, or unit testing mode. Broadly speaking, this module should only contain logic that needs to execute *before startup*, such as testing the environment in which the code is running in order to make decisions about how it should load.
-
-## [main.js](./main.js)
-
-The sole job of the `main.js` module is to create and then export the constructor function for creating a new `p5` object. This constructor function is also called `p5`, and doesn't use the typical JavaScript convention of capitalizing constructor functions. The constructor handles a number of mechanical startup concerns, including assigning functions and properties from elsewhere in the source code to the newly created `p5` object as either public or private methods and properties.
-
-Aside from the exported constructor function, the most important thing in this module is the set of functions that define the loop used by nearly every p5.js project: `preload()`, `setup()`, `draw()`, `remove()`, and so on. These functions are both available on the `p5` object as methods, and also assigned to variables in the global space for syntactic simplicity, because calling a function named `draw()` is more creatively expressive than namespacing the same functionality with an object as with `mySketch.draw()` or similar. The `friendlyBindGlobal()` function standardizes the process by which the necessary global variables can be created, notably including logging [friendly error messages](https://github.com/processing/p5.js/blob/main/contributor_docs/friendly_error_system.md) when conflicts are detected, but it is not exported from the module's internal scope.
-
-## [structure.js](./structure.js)
-
-The `structure.js` module is best thought of as a collection of ways to make *modifications* to the typical *loop structure* exposed by the `draw()` function. The functions in this module allow you to add and extract individual renders from the loop, draw the loop one frame at a time, pause and resume the loop, and so on.
-
-## [constants.js](./constants.js)
-
-The `constants.js` module provides various default values mostly related to math and web standards using clear semantic names to increase syntax clarity when they are used in other algorithms. These values are attached to the `p5` object prototype as properties by the constructor function so they can be more easily accessed by other parts of the p5.js library or by user code.
-
-## [friendly_errors/fes_core.js](./friendly_errors/fes_core.js)
-This is the main file for the Friendly Error System (FES). The Friendly Error System (FES) is a system designed to help new programmers with common user errors as they get started learning. It catches common beginning errors and provides clear language and links to help a user resolve the error. FES is only applied to functions that are ones a user might encounter when they are just starting.  You can learn more about the FES in the comment section at the top of this file, or in the [contributors_docs/friendly_error_system.md](https://github.com/processing/p5.js/blob/main/contributor_docs/friendly_error_system.md) file.
-
-## [legacy.js](./legacy.js)
-These are functions that are part of the Processing API but are not part of the p5.js API. In some cases they have a new name, in others, they are removed completely. Not all unsupported Processing functions are listed here but we try to include ones that a user coming from Processing might likely call.
-
-# Browser
-
-*utilizing and abstracting web technologies*
-
-## [environment.js](./environment.js)
-
-The `environment.js` module detects and semantically reassigns various features of the code execution environment that are arguably beyond the control of the p5.js library, such as device properties, window dimensions, and the URL bar. In general, this module should only contain code that exposes mechanics of the web that usually would not be considered part of the p5.js "sketch." This module is conceptually similar to `init.js` in that it tests the environment in which the p5.js code is executing, but one major difference is that broadly speaking the code in `environment.js` does *not* need to run solely at initialization as with `init.js`, and can be invoked whenever necessary.
-
-## [shim.js](./shim.js)
-
-Sometimes p5.js needs to use new browser APIs or other features which haven't yet been completely standardized; for example, a feature that still uses [vendor prefixes](https://developer.mozilla.org/en-US/docs/Glossary/Vendor_Prefix). In any such cases where it is necessary to handle multiple versions of the same functionality, the `shim.js` module juggles the available variants and assigns the results of that evaluation to a standardized property on the `p5` object. The rest of the p5.js library can then use that functionality without needing to constantly reconsider the specific browser implementation details.
-
-## [p5.Element.js](./p5.Element.js)
-
-Although p5.js is a general toolkit for all sorts of interactive art projects, in practice many p5.js sketches focus on rendering two dimensional graphics into a `<canvas>` element. The `p5.Element.js` module is a wrapper around the browser's DOM API which is focused on the `<canvas>` element and also handles user input events like clicks and mouse movements. Conceptually, p5.js considers the sketch to be *the entire web page*. It's useful to separate `<canvas>` from the more general DOM because so many p5.js projects focus on `<canvas>` and this enables smaller [custom builds](https://github.com/processing/p5.js/blob/main/contributor_docs/custom_p5_build.md). 
-
-# Rendering
-
-*project output options*
-
-## [rendering.js](./rendering.js)
-
-The `rendering.js` module presents the user-facing API for p5's various graphical output options. In the overwhelming majority of cases, a p5.js sketch will be output to a `<canvas>` tag on the current web page, but it is also possible to do "headless" output using `nocanvas` mode or "render" to a graphics buffer that is computed but never actually appears on the screen.
-
-## [p5.Renderer.js](./p5.Renderer.js)
-
-The `p5.Renderer.js` module provides a common base definition for a p5 project output mode that can then be extended as with [p5.Renderer2D](./p5.Renderer2D.js). For three dimensional output, see the [webgl module](../webgl/). Each `p5` object instance typically has a `Renderer` attached as a property.
-
-## [p5.Renderer2D.js](./p5.Renderer2D.js)
-
-The `p5.Renderer2D.js` module extends the generic `p5.Renderer` definition and optimizes it for two dimensional images.
-
-## [p5.Graphics.js](./p5.Graphics.js)
-
-The `p5.Graphics` module is a lightweight wrapper around renderers which is used to create output graphics in memory without ever actually drawing them on the screen.
-
-# Drawing
-
-*lines, shapes, and visual styles*
-
-## [transform.js](./transform.js)
-
-The `transform.js` module implements logic for scaling, rotation, and matrix transformations.
-
-
-## [shape/attributes.js](./shape/attributes.js)
-
-Attributes are an important part of the general API for the web, but the `attributes.js` module defines and handles miscellaneous *graphical* attributes that can be consider a set of active parameters for the current drawing style. Think of this as a grab bag of all the remaining drawing parameters that were not moved out into separate dedicated modules as with [color](../color/) and [typography](../typography/).
-
-## [shape/2d_primitives.js](./shape/2d_primitives.js)
-
-The `2d_primitives.js` module provides helper functions for drawing common shapes. The resulting drawing commands are sent to the currently active [renderer](./rendering.js).
-
-## [shape/vertex.js](./shape/vertex.js)
-
-The `vertex.js` module handles points and coordinates for drawing curves and shapes.
-
-## [shape/curves.js](./shape/curves.js)
-
-The `curves.js` module draws curves based on a set of vertices.

package/src/core/friendly_errors/index.js

@@ -1,13 +0,0 @@
-import fesCore from './fes_core';
-import stacktrace from './stacktrace';
-import validateParams from './param_validator.js';
-import sketchVerifier from './sketch_verifier.js';
-import fileErrors from './file_errors';
-
-export default function (p5) {
-  p5.registerAddon(fesCore);
-  p5.registerAddon(stacktrace);
-  p5.registerAddon(validateParams);
-  p5.registerAddon(sketchVerifier);
-  p5.registerAddon(fileErrors);
-}

package/src/core/friendly_errors/param_validator.js

@@ -1,561 +0,0 @@
-/**
- * @for p5
- * @requires core
- */
-import * as constants from '../constants.js';
-import * as z from 'zod';
-import dataDoc from '../../../docs/parameterData.json';
-
-function validateParams(p5, fn, lifecycles) {
-  // Cache for Zod schemas
-  let schemaRegistry = new Map();
-
-  // Mapping names of p5 types to their constructor functions.
-  // p5Constructors:
-  //   - Color: f()
-  //   - Graphics: f()
-  //   - Vector: f()
-  // and so on.
-  // const p5Constructors = {};
-  // NOTE: This is a tempt fix for unit test but is not correct
-  // Attaced constructors are `undefined`
-  const p5Constructors = Object.keys(p5).reduce((acc, val) => {
-    if (
-      val.match(/^[A-Z]/) && // Starts with a capital
-      !val.match(/^[A-Z][A-Z0-9]*$/) && // Is not an all caps constant
-      p5[val] instanceof Function // Is a function
-    ) {
-      acc[val] = p5[val];
-    }
-    return acc;
-  }, {});
-
-  function loadP5Constructors() {
-    // Make a list of all p5 classes to be used for argument validation
-    // This must be done only when everything has loaded otherwise we get
-    // an empty array
-    for (let key of Object.keys(p5)) {
-      // Get a list of all constructors in p5. They are functions whose names
-      // start with a capital letter
-      if (typeof p5[key] === 'function' && key[0] !== key[0].toLowerCase()) {
-        p5Constructors[key] = p5[key];
-      }
-    }
-  }
-
-  // `constantsMap` maps constants to their values, e.g.
-  // {
-  //   ADD: 'lighter',
-  //   ALT: 18,
-  //   ARROW: 'default',
-  //   AUTO: 'auto',
-  //   ...
-  // }
-  const constantsMap = {};
-  for (const [key, value] of Object.entries(constants)) {
-    constantsMap[key] = value;
-  }
-
-  // Start initializing `schemaMap` with primitive types. `schemaMap` will
-  // eventually contain both primitive types and web API objects.
-  const schemaMap = {
-    'Any': z.any(),
-    'Array': z.array(z.any()),
-    'Boolean': z.boolean(),
-    'Function': z.function(),
-    'Integer': z.number().int(),
-    'Number': z.number(),
-    'Object': z.object({}),
-    'String': z.string(),
-  };
-
-  const webAPIObjects = [
-    'AudioNode',
-    'HTMLCanvasElement',
-    'HTMLElement',
-    'KeyboardEvent',
-    'MouseEvent',
-    'RegExp',
-    'TouchEvent',
-    'UIEvent',
-    'WheelEvent'
-  ];
-
-  function generateWebAPISchemas(apiObjects) {
-    return apiObjects.reduce((acc, obj) => {
-      acc[obj] = z.custom(data => data instanceof globalThis[obj], {
-        message: `Expected a ${obj}`
-      });
-      return acc;
-    }, {});
-  }
-
-  const webAPISchemas = generateWebAPISchemas(webAPIObjects);
-  // Add web API schemas to the schema map.
-  Object.assign(schemaMap, webAPISchemas);
-
-  // For mapping 0-indexed parameters to their ordinal representation, e.g.
-  // "first" for 0, "second" for 1, "third" for 2, etc.
-  const ordinals = ["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth"];
-
-  function extractFuncNameAndClass(func) {
-    const ichDot = func.lastIndexOf('.');
-    const funcName = func.slice(ichDot + 1);
-    const funcClass = func.slice(0, ichDot !== -1 ? ichDot : 0) || 'p5';
-    return { funcName, funcClass };
-  }
-
-  function validBracketNesting(type) {
-    let level = 0;
-    for (let i = 0; i < type.length; i++) {
-      if (type[i] === '[') {
-        level++;
-      } else if (type[i] === ']') {
-        level--;
-        if (level < 0) return false;
-      }
-    }
-    return level === 0;
-  }
-
-  /**
-   * This is a helper function that generates Zod schemas for a function based on
-   * the parameter data from `docs/parameterData.json`.
-   *
-   * Example parameter data for function `background`:
-   * "background": {
-        "overloads": [
-          ["p5.Color"],
-          ["String", "Number?"],
-          ["Number", "Number?"],
-          ["Number", "Number", "Number", "Number?"],
-          ["Number[]"],
-          ["p5.Image", "Number?"]
-        ]
-      }
-   * Where each array in `overloads` represents a set of valid overloaded
-   * parameters, and `?` is a shorthand for `Optional`.
-   *
-   * @method generateZodSchemasForFunc
-   * @param {String} func - Name of the function. Expect global functions like `sin` and class methods like `p5.Vector.add`
-   * @returns {z.ZodSchema} Zod schema
-   */
-  fn.generateZodSchemasForFunc = function (func) {
-    const { funcName, funcClass } = extractFuncNameAndClass(func);
-    let funcInfo = dataDoc[funcClass][funcName];
-
-    if(!funcInfo) return;
-
-    let overloads = [];
-    if (funcInfo.hasOwnProperty('overloads')) {
-      overloads = funcInfo.overloads;
-    }
-
-    // Returns a schema for a single type, i.e. z.boolean() for `boolean`.
-    const generateTypeSchema = baseType => {
-      if (!baseType) return z.any();
-
-      let typeSchema;
-
-      // Check for constants. Note that because we're ultimately interested in the value of
-      // the constant, mapping constants to their values via `constantsMap` is
-      // necessary.
-      if (baseType in constantsMap) {
-        typeSchema = z.literal(constantsMap[baseType]);
-      }
-      // Some more constants are attached directly to p5.prototype, e.g. by addons:
-      else if (baseType.match(/^[A-Z][A-Z0-9]*$/) && baseType in fn) {
-        typeSchema = z.literal(fn[baseType]);
-      }
-      // Function types
-      else if (baseType.startsWith('function')) {
-        typeSchema = z.function();
-      }
-      // All p5 objects start with `p5` in the documentation, i.e. `p5.Camera`.
-      else if (/^p5\.[a-zA-Z0-9]+$/.exec(baseType) || baseType === 'p5') {
-        const className = baseType.substring(baseType.indexOf('.') + 1);
-        typeSchema = z.instanceof(p5Constructors[className]);
-      }
-      // For primitive types and web API objects.
-      else if (schemaMap[baseType]) {
-        typeSchema = schemaMap[baseType];
-      }
-      // Tuple types
-      else if (
-        baseType.startsWith('[') &&
-        baseType.endsWith(']') &&
-        validBracketNesting(baseType.slice(1, -1))
-      ) {
-        typeSchema = z.tuple(
-          baseType
-            .slice(1, -1)
-            .split(/, */g)
-            .map(entry => generateTypeSchema(entry))
-        );
-      }
-      // JavaScript classes, e.g. Request
-      else if (baseType.match(/^[A-Z]/) && baseType in window) {
-        typeSchema = z.instanceof(window[baseType]);
-      }
-      // Generate a schema for a single parameter that can be of multiple
-      // types / constants, i.e. `String|Number|Array`.
-      //
-      // Here, z.union() is used over z.enum() (which seems more intuitive) for
-      // constants for the following reasons:
-      // 1) z.enum() only allows a fixed set of allowable string values. However,
-      // our constants sometimes have numeric or non-primitive values.
-      // 2) In some cases, the type can be constants or strings, making z.enum()
-      // insufficient for the use case.
-      else if (baseType.includes('|') && baseType.split('|').every(t => validBracketNesting(t))) {
-        const types = baseType.split('|');
-        typeSchema = z.union(types
-          .map(t => generateTypeSchema(t))
-          .filter(s => s !== undefined));
-      } else if (baseType.endsWith('[]')) {
-        typeSchema = z.array(generateTypeSchema(baseType.slice(0, -2)));
-      } else {
-        throw new Error(`Unsupported type '${baseType}' in parameter validation. Please report this issue.`);
-      }
-
-      return typeSchema;
-    };
-
-    // Generate a schema for a single parameter. In the case where a parameter can
-    // be of multiple types, `generateTypeSchema` is called for each type.
-    const generateParamSchema = param => {
-      const isOptional = param?.endsWith('?');
-      param = param?.replace(/\?$/, '');
-
-      let schema = generateTypeSchema(param);
-
-      return isOptional ? schema.optional() : schema;
-    };
-
-    // Note that in Zod, `optional()` only checks for undefined, not the absence
-    // of value.
-    //
-    // Let's say we have a function with 3 parameters, and the last one is
-    // optional, i.e. func(a, b, c?). If we only have a z.tuple() for the
-    // parameters, where the third schema is optional, then we will only be able
-    // to validate func(10, 10, undefined), but not func(10, 10), which is
-    // a completely valid call.
-    //
-    // Therefore, on top of using `optional()`, we also have to generate parameter
-    // combinations that are valid for all numbers of parameters.
-    const generateOverloadCombinations = params => {
-      // No optional parameters, return the original parameter list right away.
-      if (!params.some(p => p?.endsWith('?'))) {
-        return [params];
-      }
-
-      const requiredParamsCount = params.filter(p => p === null || !p.endsWith('?')).length;
-      const result = [];
-
-      for (let i = requiredParamsCount; i <= params.length; i++) {
-        result.push(params.slice(0, i));
-      }
-
-      return result;
-    };
-
-    // Generate schemas for each function overload and merge them
-    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 overloadSchemas.length === 1
-      ? overloadSchemas[0]
-      : z.union(overloadSchemas);
-  }
-
-  /**
-   * Finds the closest schema to the input arguments.
-   *
-   * This is a helper function that identifies the closest schema to the input
-   * arguments, in the case of an initial validation error. We will then use the
-   * closest schema to generate a friendly error message.
-   *
-   * @private
-   * @param {z.ZodSchema} schema - Zod schema.
-   * @param {Array} args - User input arguments.
-   * @returns {z.ZodSchema} Closest schema matching the input arguments.
-   */
-  fn.findClosestSchema = function (schema, args) {
-    if (!(schema instanceof z.ZodUnion)) {
-      return schema;
-    }
-
-    // Helper function that scores how close the input arguments are to a schema.
-    // Lower score means closer match.
-    const scoreSchema = schema => {
-      let score = Infinity;
-      if (!(schema instanceof z.ZodTuple)) {
-        console.warn('Schema below is not a tuple: ');
-        printZodSchema(schema);
-        return score;
-      }
-
-      const numArgs = args.length;
-      const schemaItems = schema.items;
-      const numSchemaItems = schemaItems.length;
-      const numRequiredSchemaItems = schemaItems.filter(item => !item.isOptional()).length;
-
-      if (numArgs >= numRequiredSchemaItems && numArgs <= numSchemaItems) {
-        score = 0;
-      }
-      // Here, give more weight to mismatch in number of arguments.
-      //
-      // For example, color() can either take [Number, Number?] or
-      // [Number, Number, Number, Number?] as list of parameters.
-      // If the user passed in 3 arguments, [10, undefined, undefined], it's
-      // more than likely that they intended to pass in 3 arguments, but the
-      // last two arguments are invalid.
-      //
-      // If there's no bias towards matching the number of arguments, the error
-      // message will show that we're expecting at most 2 arguments, but more
-      // are received.
-      else {
-        score = Math.abs(
-          numArgs < numRequiredSchemaItems ? numRequiredSchemaItems - numArgs : numArgs - numSchemaItems
-        ) * 4;
-      }
-
-      for (let i = 0; i < Math.min(schemaItems.length, args.length); i++) {
-        const paramSchema = schemaItems[i];
-        const arg = args[i];
-
-        if (!paramSchema.safeParse(arg).success) score++;
-      }
-
-      return score;
-    };
-
-    // Default to the first schema, so that we are guaranteed to return a result.
-    let closestSchema = schema._def.options[0];
-    // We want to return the schema with the lowest score.
-    let bestScore = Infinity;
-
-    const schemaUnion = schema._def.options;
-    schemaUnion.forEach(schema => {
-      const score = scoreSchema(schema);
-      if (score < bestScore) {
-        closestSchema = schema;
-        bestScore = score;
-      }
-    });
-
-    return closestSchema;
-  }
-
-  /**
-   * Prints a friendly error message after parameter validation, if validation
-   * has failed.
-   *
-   * @method _friendlyParamError
-   * @private
-   * @param {z.ZodError} zodErrorObj - The Zod error object containing validation errors.
-   * @param {String} func - Name of the function. Expect global functions like `sin` and class methods like `p5.Vector.add`
-   * @returns {String} The friendly error message.
-   */
-  fn.friendlyParamError = function (zodErrorObj, func, args) {
-    let message = '🌸 p5.js says: ';
-    let isVersionError = false;
-    // The `zodErrorObj` might contain multiple errors of equal importance
-    // (after scoring the schema closeness in `findClosestSchema`). Here, we
-    // always print the first error so that user can work through the errors
-    // one by one.
-    let currentError = zodErrorObj.errors[0];
-
-    // Helper function to build a type mismatch message.
-    const buildTypeMismatchMessage = (actualType, expectedTypeStr, position) => {
-      const positionStr = position ? `at the ${ordinals[position]} parameter` : '';
-      const actualTypeStr = actualType ? `, but received ${actualType}` : '';
-      return `Expected ${expectedTypeStr} ${positionStr}${actualTypeStr}`;
-    }
-
-    // Union errors occur when a parameter can be of multiple types but is not
-    // of any of them. In this case, aggregate all possible types and print
-    // a friendly error message that indicates what the expected types are at
-    // which position (position is not 0-indexed, for accessibility reasons).
-    const processUnionError = (error) => {
-      const expectedTypes = new Set();
-      let actualType;
-
-      error.unionErrors.forEach(err => {
-        const issue = err.issues[0];
-        if (issue) {
-          if (!actualType) {
-            actualType = issue.received;
-          }
-
-          if (issue.code === 'invalid_type') {
-            expectedTypes.add(issue.expected);
-          }
-          // The case for constants. Since we don't want to print out the actual
-          // constant values in the error message, the error message will
-          // direct users to the documentation.
-          else if (issue.code === 'invalid_literal') {
-            expectedTypes.add("constant (please refer to documentation for allowed values)");
-          } else if (issue.code === 'custom') {
-            const match = issue.message.match(/Input not instance of (\w+)/);
-            if (match) expectedTypes.add(match[1]);
-          }
-        }
-      });
-
-      if (expectedTypes.size > 0) {
-        if (error.path?.length > 0 && args[error.path[0]] instanceof Promise)  {
-          message += 'Did you mean to put `await` before a loading function? ' +
-            'An unexpected Promise was found. ';
-          isVersionError = true;
-        }
-
-        const expectedTypesStr = Array.from(expectedTypes).join(' or ');
-        const position = error.path.join('.');
-
-        message += buildTypeMismatchMessage(actualType, expectedTypesStr, position);
-      }
-
-      return message;
-    }
-
-    switch (currentError.code) {
-      case 'invalid_union': {
-        processUnionError(currentError);
-        break;
-      }
-      case 'too_small': {
-        const minArgs = currentError.minimum;
-        message += `Expected at least ${minArgs} argument${minArgs > 1 ? 's' : ''}, but received fewer`;
-        break;
-      }
-      case 'invalid_type': {
-        message += buildTypeMismatchMessage(currentError.received, currentError.expected, currentError.path.join('.'));
-        break;
-      }
-      case 'too_big': {
-        const maxArgs = currentError.maximum;
-        message += `Expected at most ${maxArgs} argument${maxArgs > 1 ? 's' : ''}, but received more`;
-        break;
-      }
-      default: {
-        console.log('Zod error object', currentError);
-      }
-    }
-
-    // Let the user know which function is generating the error.
-    message += ` in ${func}().`;
-
-    // Generates a link to the documentation based on the given function name.
-    // TODO: Check if the link is reachable before appending it to the error
-    // message.
-    const generateDocumentationLink = (func) => {
-      const { funcName, funcClass } = extractFuncNameAndClass(func);
-      const p5BaseUrl = 'https://p5js.org/reference';
-      const url = `${p5BaseUrl}/${funcClass}/${funcName}`;
-
-      return url;
-    }
-
-    if (currentError.code === 'too_big' || currentError.code === 'too_small') {
-      const documentationLink = generateDocumentationLink(func);
-      message += ` For more information, see ${documentationLink}.`;
-    }
-
-    if (isVersionError) {
-      p5._error(this, message);
-    } else {
-      console.log(message);
-    }
-    return message;
-  }
-
-  /**
-   * Runs parameter validation by matching the input parameters to Zod schemas
-   * generated from the parameter data from `docs/parameterData.json`.
-   *
-   * @private
-   * @param {String} func - Name of the function.
-   * @param {Array} args - User input arguments.
-   * @returns {Object} The validation result.
-   * @returns {Boolean} result.success - Whether the validation was successful.
-   * @returns {any} [result.data] - The parsed data if validation was successful.
-   * @returns {String} [result.error] - The validation error message if validation has failed.
-   */
-  fn.validate = function (func, args) {
-    if (p5.disableFriendlyErrors) {
-      return; // skip FES
-    }
-
-    if (!Array.isArray(args)) {
-      args = Array.from(args);
-    }
-
-    // An edge case: even when all arguments are optional and therefore,
-    // 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)) {
-      const undefinedErrorMessage = `🌸 p5.js says: All arguments for ${func}() are undefined. There is likely an error in the code.`;
-
-      return {
-        success: false,
-        error: undefinedErrorMessage
-      };
-    }
-
-    let funcSchemas = schemaRegistry.get(func);
-    if (!funcSchemas) {
-      funcSchemas = fn.generateZodSchemasForFunc(func);
-      if (!funcSchemas) return;
-      schemaRegistry.set(func, funcSchemas);
-    }
-
-    try {
-      return {
-        success: true,
-        data: funcSchemas.parse(args)
-      };
-    } catch (error) {
-      const closestSchema = fn.findClosestSchema(funcSchemas, args);
-      const zodError = closestSchema.safeParse(args).error;
-      const errorMessage = fn.friendlyParamError(zodError, func, args);
-
-      return {
-        success: false,
-        error: errorMessage
-      };
-    }
-  };
-
-  lifecycles.presetup = function(){
-    loadP5Constructors();
-
-    const excludes = ['validate'];
-    for(const f in this){
-      if(!excludes.includes(f) && !f.startsWith('_') && typeof this[f] === 'function'){
-        const copy = this[f];
-
-        this[f] = function(...args) {
-          this.validate(f, args);
-          return copy.call(this, ...args);
-        };
-      }
-    }
-  };
-}
-
-export default validateParams;
-
-if (typeof p5 !== 'undefined') {
-  validateParams(p5, p5.prototype);
-}