tests

Author: avivkeller

src/generators/jsx-ast/utils/__tests__/createSignatureElements.test.mjs

@@ -0,0 +1,168 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import {
+  extractTypesAndDescription,
+  processListItemsIntoProperties,
+  generateSignatures,
+  getFullName,
+} from '../createSignatureElements.mjs';
+
+describe('createSignatureElements', () => {
+  describe('extractTypesAndDescription', () => {
+    it('should extract types and description from content nodes', () => {
+      const contentNodes = [
+        { type: 'link', children: [{ type: 'inlineCode', value: '<string>' }] },
+        { type: 'text', value: ' | ' },
+        { type: 'link', children: [{ type: 'inlineCode', value: '<number>' }] },
+        { type: 'text', value: ' - This is a description' },
+      ];
+
+      const result = extractTypesAndDescription(contentNodes);
+
+      assert.equal(result.types.length, 3);
+      assert.equal(result.description.length, 1);
+      assert.equal(result.description[0].value, ' - This is a description');
+    });
+
+    it('should handle generic types correctly', () => {
+      const contentNodes = [
+        { type: 'link', children: [{ type: 'inlineCode', value: '<T>' }] },
+        { type: 'text', value: ' - Description of generic' },
+      ];
+
+      const result = extractTypesAndDescription(contentNodes);
+
+      assert.equal(result.types.length, 1);
+      assert.equal(result.types[0].children[0].value, '<T>');
+      assert.equal(result.description.length, 1);
+    });
+
+    it('should handle content with no types', () => {
+      const contentNodes = [{ type: 'text', value: 'Only description' }];
+
+      const result = extractTypesAndDescription(contentNodes);
+
+      assert.equal(result.types.length, 0);
+      assert.equal(result.description.length, 1);
+      assert.equal(result.description[0].value, 'Only description');
+    });
+  });
+
+  describe('processListItemsIntoProperties', () => {
+    it('should convert list items into property data objects', () => {
+      const listItems = [
+        {
+          children: [
+            {
+              type: 'paragraph',
+              children: [
+                { type: 'text', value: 'propName' },
+                {
+                  type: 'link',
+                  children: [{ type: 'inlineCode', value: '<string>' }],
+                },
+                { type: 'text', value: ' - Description text' },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = processListItemsIntoProperties(listItems);
+
+      assert.equal(result.length, 1);
+      assert.ok(result[0].hasTypes);
+      assert.ok(result[0].hasDescription);
+    });
+  });
+
+  describe('generateSignatures', () => {
+    it('should generate a single signature when no optional parameters', () => {
+      const functionName = 'testFunction';
+      const signature = {
+        params: [
+          { name: 'param1', optional: false },
+          { name: 'param2', optional: false },
+        ],
+        return: { type: 'string' },
+      };
+
+      const result = generateSignatures(functionName, signature);
+
+      assert.equal(result.length, 1);
+      assert.equal(result[0], 'testFunction(param1, param2): string');
+    });
+
+    it('should generate multiple signatures for optional parameters', () => {
+      const functionName = 'testFunction';
+      const signature = {
+        params: [
+          { name: 'required', optional: false },
+          { name: 'optional1', optional: true },
+          { name: 'optional2', optional: true },
+        ],
+        return: { type: 'number' },
+      };
+
+      const result = generateSignatures(functionName, signature);
+
+      assert.equal(result.length, 4);
+      assert.ok(result.includes('testFunction(required): number'));
+      assert.ok(result.includes('testFunction(required, optional1?): number'));
+      assert.ok(result.includes('testFunction(required, optional2?): number'));
+      assert.ok(
+        result.includes(
+          'testFunction(required, optional1?, optional2?): number'
+        )
+      );
+    });
+
+    it('should handle functions without return type', () => {
+      const functionName = 'voidFunction';
+      const signature = {
+        params: [{ name: 'param', optional: false }],
+        return: null,
+      };
+
+      const result = generateSignatures(functionName, signature);
+
+      assert.equal(result[0], 'voidFunction(param)');
+    });
+  });
+
+  describe('getFullName', () => {
+    it('should extract function name from code in text', () => {
+      const heading = {
+        name: 'functionName',
+        text: 'The `obj.functionName` function',
+      };
+
+      const result = getFullName(heading);
+
+      assert.equal(result, 'obj.functionName');
+    });
+
+    it('should return just the name when no code is found', () => {
+      const heading = {
+        name: 'functionName',
+        text: 'The functionName function',
+      };
+
+      const result = getFullName(heading);
+
+      assert.equal(result, 'functionName');
+    });
+
+    it('should handle complex function names', () => {
+      const heading = {
+        name: 'add',
+        text: 'Using `math.add` to add numbers',
+      };
+
+      const result = getFullName(heading);
+
+      assert.equal(result, 'math.add');
+    });
+  });
+});

src/generators/jsx-ast/utils/createSignatureElements.mjs

@@ -8,7 +8,7 @@ import parseSignature from '../../legacy-json/utils/parseSignature.mjs';
  * Extracts types and description from content nodes
  * @param {import('@types/mdast').Node[]} contentNodes - Content nodes to process
  */
-const extractTypesAndDescription = contentNodes => {
+export const extractTypesAndDescription = contentNodes => {
   const types = [];
   let i = 0;
 
@@ -51,7 +51,7 @@ const extractTypesAndDescription = contentNodes => {
  * @param {import('@types/mdast').ListItem[]} items - List items to process
  * @param {string} prefix - Property name prefix for nested properties
  */
-const processListItemsIntoProperties = (items, prefix = '') => {
+export const processListItemsIntoProperties = (items, prefix = '') => {
   const properties = [];
 
   for (const item of items) {
@@ -123,7 +123,7 @@ const processListItemsIntoProperties = (items, prefix = '') => {
  * Creates a table from a list of properties
  * @param {import('mdast').List} node
  */
-const createPropertyTable = node => {
+export const createPropertyTable = node => {
   // Process all properties
   const allProperties = processListItemsIntoProperties(node.children);
 
@@ -166,7 +166,7 @@ const createPropertyTable = node => {
  * @param {string} functionName - Name of the function
  * @param {import('../../legacy-json/types.d.ts').MethodSignature} signature - Signature object
  */
-const generateSignatures = (functionName, signature) => {
+export const generateSignatures = (functionName, signature) => {
   const { params, return: returnType } = signature;
   const returnStr = returnType ? `: ${returnType.type}` : '';
 
@@ -219,7 +219,7 @@ const generateSignatures = (functionName, signature) => {
  * @param {string} functionName - Name of the function
  * @param {import('../../legacy-json/types.d.ts').MethodSignature} signature - Signature object
  */
-const createSignatureCodeBlock = (functionName, signature) => {
+export const createSignatureCodeBlock = (functionName, signature) => {
   const signatures = generateSignatures(functionName, signature);
   const codeContent = signatures.join('\n');
   return createElement('pre', codeContent);

src/generators/legacy-json/utils/parseSignature.mjs

@@ -5,12 +5,13 @@ import { PARAM_EXPRESSION } from '../constants.mjs';
 const OPTIONAL_LEVEL_CHANGES = { '[': 1, ']': -1, ' ': 0 };
 
 /**
- * @param {String} char
  * @param {Number} depth
+ * @param {String} char
  * @returns {Number}
  */
-const updateDepth = (char, depth) =>
-  depth + (OPTIONAL_LEVEL_CHANGES[char] || 0);
+const updateDepth = (depth, char) => {
+  return depth + (OPTIONAL_LEVEL_CHANGES[char] || 0);
+};
 
 /**
  * @param {string} parameterName