Function extractUtilities

webpackConfig/webextension.content.generateChibi.js:154–219

(sourceFile)

}

function extractUtilities(sourceFile) {
  const functionParts = [];

  ts.forEachChild(sourceFile, node => {
    if (
      ts.isExportAssignment(node) &&
      node.expression &&
      ts.isObjectLiteralExpression(node.expression)
    ) {
      const objectLiteral = node.expression;
      objectLiteral.properties.forEach(prop => {
        if (prop.name) {
          const part = [];
          const functionName = prop.name.text;

          const args = prop.parameters || prop.initializer?.parameters || [];
          const argsString = args.map((param, index) => {
            const paramName = param.name.text || (param.dotDotDotToken ? '...args' : 'param');
            const optional = param.questionToken || param.initializer ? '?' : '';
            if (!param.type?.getText() && param.initializer?.getText()) {
              throw new Error(`Utility ${functionName} parameter ${paramName} is missing type annotation`);
            }
            const type = param.type?.getText() || 'any';
            const dotDotDot = param.dotDotDotToken ? '...' : '';
            return `${dotDotDot}${paramName}${optional}: ${type}`;
          });

          const jsDocs = prop.jsDoc ? prop.jsDoc.map(doc => `  ${doc.getText()}`) : [];

          const returnTypeNames =
            prop.type?.getText() ||
            prop.initializer?.type?.getText() ||
            `ReturnType<typeof utilitiesRegistry.${functionName}>`;

          const typeParameters = prop.typeParameters || prop.initializer?.typeParameters;
          const typeParametersString = typeParameters
            ? typeParameters
                .filter(param => !param.name || param.name.text !== 'Input')
                .map(param => param.getText())
                .join(', ')
            : '';

          console.log(`Utility Name: ${functionName}`);

          part.push(
            `${jsDocs.join('\n').replace('*/', `* @see {@link  utilitiesRegistry.${functionName}} for implementation details\n   */`)}`,
          );

          part.push(
            `  ${functionName}: CT.MatchesType<Input, CT.InputTypeUtility<typeof utilitiesRegistry.${functionName}>> extends true`,
          );
          part.push(
            `    ? ${typeParametersString ? `<${typeParametersString}>` : ''}(${argsString.slice(1).join(', ')}) => ${returnTypeNames}`,
          );
          part.push(
            `    : CT.TypeMismatchError<'${functionName}', Input, CT.InputTypeUtility<typeof utilitiesRegistry.${functionName}>>;`,
          );