15503494088

Committed 07 Jun 2025 02:52AM CUT coverage: 95.479% (-0.01%) from 95.49%

Build # 15503494088

Build Type

Pull #999

github

Committed by

web-flow

Commit Message

Merge c42d1b242 into ec11d1f1e

Pull Request Pull Request #999: Packages ready to publish

Run Details

1393 of 1494 branches covered (93.24%)

Branch coverage included in aggregate %.

4605 of 4788 relevant lines covered (96.18%)

522.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.0

/packages/react-docgen/src/utils/expressionTo.ts

/*eslint no-loop-func: 0, no-use-before-define: 0*/

import resolveToValue from './resolveToValue.js';
import type { NodePath } from '@babel/traverse';
import type { Node } from '@babel/types';

/**
 * Splits a MemberExpression or CallExpression into parts.
 * E.g. foo.bar.baz becomes ['foo', 'bar', 'baz']
 */
function toArray(path: NodePath<Node | null>): string[] {
  const parts = [path];
  let result: string[] = [];

  while (parts.length > 0) {
    path = parts.shift() as NodePath;
    if (path.isCallExpression()) {
      parts.push(path.get('callee'));
      continue;
    } else if (path.isMemberExpression()) {
      parts.push(path.get('object'));
      const property = path.get('property');

      if (path.node.computed) {
        const resolvedPath = resolveToValue(property);

        if (resolvedPath !== undefined) {
          result = result.concat(toArray(resolvedPath));
        } else {
          result.push('<computed>');
        }
      } else if (property.isIdentifier()) {
        result.push(property.node.name);
      } else if (property.isPrivateName()) {
        // new test
        result.push(`#${property.get('id').node.name}`);
      }
      continue;
    } else if (path.isIdentifier()) {
      result.push(path.node.name);
      continue;
    } else if (path.isTSAsExpression()) {
      const expression = path.get('expression');

      if (expression.isIdentifier()) {
        result.push(expression.node.name);
      }
      continue;
    } else if (path.isLiteral() && path.node.extra?.raw) {
      result.push(path.node.extra.raw as string);
      continue;
    } else if (path.isThisExpression()) {
      result.push('this');
      continue;
    } else if (path.isObjectExpression()) {
      const properties = path.get('properties').map(function (property) {
        if (property.isSpreadElement()) {
          return `...${toString(property.get('argument'))}`;
        } else if (property.isObjectProperty()) {
          return (
            toString(property.get('key')) +
            ': ' +
            toString(property.get('value'))
          );
        } else if (property.isObjectMethod()) {
          return toString(property.get('key')) + ': <function>';
        } else {
          throw new Error('Unrecognized object property type');
        }
      });

      result.push('{' + properties.join(', ') + '}');
      continue;
    } else if (path.isArrayExpression()) {
      result.push(
        '[' +
          path
            .get('elements')
            .map(function (el) {
              return toString(el);
            })
            .join(', ') +
          ']',
      );
      continue;
    }
  }

  return result.reverse();
}

/**
 * Creates a string representation of a member expression.
 */
function toString(path: NodePath<Node | null>): string {
  return toArray(path).join('.');
}

export { toString as String, toArray as Array };

1	/eslint no-loop-func: 0, no-use-before-define: 0/
2
3	import resolveToValue from './resolveToValue.js';	3✔
4	import type { NodePath } from '@babel/traverse';
5	import type { Node } from '@babel/types';
6
7	/**
8	* Splits a MemberExpression or CallExpression into parts.
9	* E.g. foo.bar.baz becomes ['foo', 'bar', 'baz']
10	*/
11	function toArray(path: NodePath<Node \| null>): string[] {	957✔
12	const parts = [path];	957✔
13	let result: string[] = [];	957✔
14
15	while (parts.length > 0) {	957✔
16	path = parts.shift() as NodePath;	1,476✔
17	if (path.isCallExpression()) {	1,476!
18	parts.push(path.get('callee'));	×
19	continue;	×
20	} else if (path.isMemberExpression()) {	1,476✔
21	parts.push(path.get('object'));	519✔
22	const property = path.get('property');	519✔
23
24	if (path.node.computed) {	519✔
25	const resolvedPath = resolveToValue(property);	15✔
26
27	if (resolvedPath !== undefined) {	15✔
28	result = result.concat(toArray(resolvedPath));	15✔
29	} else {	15!
30	result.push('<computed>');	×
31	}	×
32	} else if (property.isIdentifier()) {	519✔
33	result.push(property.node.name);	504✔
34	} else if (property.isPrivateName()) {	504!
35	// new test
36	result.push(`#${property.get('id').node.name}`);	×
37	}	×
38	continue;	519✔
39	} else if (path.isIdentifier()) {	1,476✔
40	result.push(path.node.name);	921✔
41	continue;	921✔
42	} else if (path.isTSAsExpression()) {	957✔
43	const expression = path.get('expression');	21✔
44
45	if (expression.isIdentifier()) {	21✔
46	result.push(expression.node.name);	21✔
47	}	21✔
48	continue;	21✔
49	} else if (path.isLiteral() && path.node.extra?.raw) {	36✔
50	result.push(path.node.extra.raw as string);	6✔
51	continue;	6✔
52	} else if (path.isThisExpression()) {	15!
53	result.push('this');	×
54	continue;	×
55	} else if (path.isObjectExpression()) {	9✔
56	const properties = path.get('properties').map(function (property) {	9✔
57	if (property.isSpreadElement()) {	9✔
58	return `...${toString(property.get('argument'))}`;	3✔
59	} else if (property.isObjectProperty()) {	9✔
60	return (	3✔
61	toString(property.get('key')) +	3✔
62	': ' +	3✔
63	toString(property.get('value'))	3✔
64	);
65	} else if (property.isObjectMethod()) {	3✔
66	return toString(property.get('key')) + ': <function>';	3✔
67	} else {	3!
68	throw new Error('Unrecognized object property type');	×
69	}	×
70	});	9✔
71
72	result.push('{' + properties.join(', ') + '}');	9✔
73	continue;	9✔
74	} else if (path.isArrayExpression()) {	9!
75	result.push(	×
76	'[' +	×
77	path	×
78	.get('elements')	×
79	.map(function (el) {	×
80	return toString(el);	×
81	})	×
82	.join(', ') +	×
83	']',	×
84	);	×
85	continue;	×
86	}	×
87	}	1,476✔
88
89	return result.reverse();	957✔
90	}	957✔
91
92	/**
93	* Creates a string representation of a member expression.
94	*/
95	function toString(path: NodePath<Node \| null>): string {	450✔
96	return toArray(path).join('.');	450✔
97	}	450✔
98
99	export { toString as String, toArray as Array };

reactjs / react-docgen / 15503494088

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous