Function flattenOverloads

utils/convert.mjs:105–158

  // Reduce the amount of information in each function's overloads, while
  // keeping all the essential data available.
  const flattenOverloads = funcObj => {
    const result = {};

    const processOverload = overload => {
      if (overload.params) {
        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 processParam = param => {
      let type = param.type;
      if (param.optional) {
        type += '?';
      }
      if (param.rest) {
        type = `...${type}[]`;
      }
      return type;
    };

    // In some cases, even when the arguments are intended to mean different
    // things, their types and order are identical. Since the exact meaning
    // of the arguments is less important for parameter validation, we'll
    // perform overload deduplication here.
    const removeDuplicateOverloads = (overload, uniqueOverloads) => {
      const overloadString = JSON.stringify(overload);
      if (uniqueOverloads.has(overloadString)) {
        return false;
      }
      uniqueOverloads.add(overloadString);
      return true;
    };

    for (const [key, value] of Object.entries(funcObj)) {
      if (value && typeof value === 'object' && value.overloads) {
        const uniqueOverloads = new Set();
        result[key] = {
          overloads: Object.values(value.overloads)
            .map(overload => processOverload(overload))
            .filter(overload =>
              removeDuplicateOverloads(overload, uniqueOverloads)
            )
        };
      } else {
        result[key] = value;
      }
    }

    return result;
  };

  for (const classItem in data) {
    if (typeof data[classItem] === 'object') {