little bit more coverage for methods

Signed-off-by: flakey5 <73616808+flakey5@users.noreply.github.com>

Author: flakey5

src/generators/json/utils/sections/__tests__/method.test.mjs

@@ -124,6 +124,153 @@ describe('parseSignatures', () => {
     });
   });
 
+  test('`something.regexExtractedReturnType()`', () => {
+    /**
+     * ### `something.regexExtractedReturnType()`
+     *
+     * * this line should be ignored
+     * * Returns: {integer} something something something
+     */
+
+    /**
+     * @type {import('../../../../../utils/buildHierarchy.mjs').HierarchizedEntry}
+     */
+    const entry = {
+      heading: {
+        data: {
+          type: 'classMethod',
+          text: '`something.regexExtractedReturnType()`',
+        },
+      },
+      content: {
+        type: 'root',
+        children: [
+          undefined, // this should be ignore
+          {
+            type: 'list',
+            children: [
+              {
+                type: 'listItem',
+                children: [
+                  {
+                    type: 'paragraph',
+                    children: [
+                      {
+                        type: 'text',
+                        value: 'this line should be ignored',
+                      },
+                    ],
+                  },
+                ],
+              },
+              {
+                type: 'listItem',
+                children: [
+                  {
+                    type: 'paragraph',
+                    children: [
+                      {
+                        type: 'text',
+                        value:
+                          'Returns: {integer} something something something',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    /**
+     * @type {import('../../../generated/generated.d.ts').Method}
+     */
+    const section = {};
+
+    parseSignatures(entry, section);
+
+    assert.deepStrictEqual(section, {
+      signatures: [
+        {
+          '@returns': {
+            '@type': 'integer',
+            description: 'something something something',
+          },
+          parameters: undefined,
+        },
+      ],
+    });
+  });
+
+  test('`something.doThingWithUndefinedReturnType()`', () => {
+    /**
+     * ### `something.doThingWithReturnType()`
+     *
+     * * Returns: `undefined`
+     */
+
+    /**
+     * @type {import('../../../../../utils/buildHierarchy.mjs').HierarchizedEntry}
+     */
+    const entry = {
+      heading: {
+        data: {
+          type: 'classMethod',
+          text: '`something.doThingWithUndefinedReturnType()`',
+        },
+      },
+      content: {
+        type: 'root',
+        children: [
+          undefined, // this should be ignore
+          {
+            type: 'list',
+            children: [
+              {
+                type: 'listItem',
+                children: [
+                  {
+                    type: 'paragraph',
+                    children: [
+                      {
+                        type: 'text',
+                        value: 'Returns: ',
+                      },
+                      {
+                        type: 'inlineCode',
+                        value: 'undefined',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    /**
+     * @type {import('../../../generated/generated.d.ts').Method}
+     */
+    const section = {};
+
+    parseSignatures(entry, section);
+
+    assert.deepStrictEqual(section, {
+      signatures: [
+        {
+          '@returns': {
+            '@type': 'undefined',
+          },
+          parameters: undefined,
+        },
+      ],
+    });
+  });
+
   test('`something.doThingWithoutParameterList(parameter)`', () => {
     /**
      * ### `something.doThingWithoutParameterList()`

src/generators/json/utils/sections/method.mjs

@@ -80,12 +80,13 @@ export function parseParameterListNode({ children }) {
     }
     case 'text': {
       // paragraph is something like: "Returns: {integer}""
-
       const returnRegex = METHOD_RETURN_TYPE_EXTRACTOR.exec(firstChild.value);
+
       if (returnRegex) {
         const [, , type, description] = returnRegex;
         parameter['@type'] = type.split('|').map(type => type.trim());
         parameter.description = description?.trim();
+        parameter.returnType = true;
 
         // Any nodes after this one should be part of the description
         descriptionIndex = 1;
@@ -119,7 +120,7 @@ export function parseParameterListNode({ children }) {
           if (types.length === 0) {
             parameter['@type'] = 'any';
           } else {
-            parameter['@type'] = types.length === 1 ? types[0] : types;
+            parameter['@type'] = types;
           }
 
           descriptionIndex = endingIndex + 1;
@@ -140,6 +141,10 @@ export function parseParameterListNode({ children }) {
     }
   }
 
+  if (Array.isArray(parameter['@type']) && parameter['@type'].length === 1) {
+    parameter['@type'] = parameter['@type'][0];
+  }
+
   if (descriptionIndex && descriptionIndex < paragraph.children.length) {
     parameter.description ??= '';
     parameter.description += transformNodesToString(