14773577666

Committed 01 May 2025 10:00AM CUT coverage: 87.338%. Remained the same

Build # 14773577666

Build Type

Pull #384

github

Committed by

web-flow

Commit Message

Merge df5333731 into 327e06fbd

Pull Request Pull Request #384: chore(deps): update dependency eslint-plugin-node-dependencies to v1

Run Details

372 of 455 branches covered (81.76%)

Branch coverage included in aggregate %.

911 of 1014 relevant lines covered (89.84%)

176.76 hits per line

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

86.6

/src/utils/ast/js/utils.ts

// eslint-disable-next-line @eslint-community/eslint-comments/disable-enable-pair -- ignore
/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */
import type { AST } from "vue-eslint-parser";
import type { RuleContext } from "../../../types";
// @ts-expect-error -- no type def
import * as eslintUtils from "@eslint-community/eslint-utils";
import type { Variable } from "eslint-scope";
import { getSourceCode } from "../../compat";

/**
 * Gets the property name of a given node.
 */
export function getStaticPropertyName(
  node: AST.ESLintProperty | AST.ESLintMemberExpression,
  context: RuleContext,
): string | null {
  let key;
  if (node.type === "Property") {
    key = node.key;
    if (!node.computed) {
      if (key.type === "Identifier") {
        return key.name;
      }
    }
  } else if (node.type === "MemberExpression") {
    key = node.property;
    if (!node.computed) {
      if (key.type === "Identifier") {
        return key.name;
      }
      return null;
    }
  } else {
    return null;
  }
  if (key.type === "Literal" || key.type === "TemplateLiteral") {
    return getStringLiteralValue(key);
  }
  if (key.type === "Identifier") {
    const init = findInitNode(context, key);
    if (init) {
      if (
        init.node.type === "Literal" ||
        init.node.type === "TemplateLiteral"
      ) {
        return getStringLiteralValue(init.node);
      }
    }
  }
  return null;
}

/**
 * Gets the string of a given node.
 */
export function getStringLiteralValue(
  node: AST.ESLintLiteral | AST.ESLintTemplateLiteral,
): string | null {
  if (node.type === "Literal") {
    if (node.value == null) {
      if ((node as any).bigint != null) {
        return String((node as any).bigint);
      }
    }
    return String(node.value);
  }
  if (node.type === "TemplateLiteral") {
    if (node.expressions.length === 0 && node.quasis.length === 1) {
      return node.quasis[0].value.cooked;
    }
  }
  return null;
}

/**
 * Find the variable of a given name.
 */
function findVariable(
  context: RuleContext,
  node: AST.ESLintIdentifier,
): Variable | null {
  return eslintUtils.findVariable(getScope(context, node), node);
}

/**
 * Get the value of a given node if it's a static value.
 */
export function getStaticValue(
  context: RuleContext,
  node: AST.ESLintNode,
): { value: any } | null {
  return eslintUtils.getStaticValue(node, getScope(context, node));
}

/**
 * Find the node that initial value.
 */
export function findInitNode(
  context: RuleContext,
  node: AST.ESLintIdentifier,
): { node: AST.ESLintExpression; reads: AST.ESLintIdentifier[] } | null {
  const variable = findVariable(context, node);
  if (!variable) {
    return null;
  }
  if (variable.defs.length === 1) {
    const def = variable.defs[0];
    if (
      def.type === "Variable" &&
      def.parent.kind === "const" &&
      def.node.init
    ) {
      let init = def.node.init as AST.ESLintExpression;
      const reads = variable.references
        .filter((ref) => ref.isRead())
        .map((ref) => ref.identifier as AST.ESLintIdentifier);
      if (init.type === "Identifier") {
        const data = findInitNode(context, init);
        if (!data) {
          return null;
        }
        init = data.node;
        reads.push(...data.reads);
      }

      return {
        node: init,
        reads,
      };
    }
  }
  return null;
}

/**
 * Gets the scope for the current node
 */
function getScope(context: RuleContext, currentNode: AST.ESLintNode) {
  // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
  const inner = currentNode.type !== "Program";
  const scopeManager = getSourceCode(context).scopeManager;

  let node: any = currentNode;
  for (; node; node = node.parent || null) {
    const scope = scopeManager.acquire(node, inner);

    if (scope) {
      if (scope.type === "function-expression-name") {
        return scope.childScopes[0];
      }
      return scope;
    }
  }

  return scopeManager.scopes[0];
}

1	// eslint-disable-next-line @eslint-community/eslint-comments/disable-enable-pair -- ignore	316✔
2	/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */
3	import type { AST } from "vue-eslint-parser";
4	import type { RuleContext } from "../../../types";
5	// @ts-expect-error -- no type def
6	import * as eslintUtils from "@eslint-community/eslint-utils";	1✔
7	import type { Variable } from "eslint-scope";
8	import { getSourceCode } from "../../compat";	1✔
9
10	/**
11	* Gets the property name of a given node.
12	*/
13	export function getStaticPropertyName(
14	node: AST.ESLintProperty \| AST.ESLintMemberExpression,
15	context: RuleContext,
16	): string \| null {
17	let key;
18	if (node.type === "Property") {	184✔
19	key = node.key;	165✔
20	if (!node.computed) {	165✔
21	if (key.type === "Identifier") {	160✔
22	return key.name;	93✔
23	}
24	}
25	} else if (node.type === "MemberExpression") {	19!
26	key = node.property;	19✔
27	if (!node.computed) {	19✔
28	if (key.type === "Identifier") {	15✔
29	return key.name;	15✔
30	}
31	return null;	×
32	}
33	} else {
34	return null;	×
35	}
36	if (key.type === "Literal" \|\| key.type === "TemplateLiteral") {	76✔
37	return getStringLiteralValue(key);	74✔
38	}
39	if (key.type === "Identifier") {	2✔
40	const init = findInitNode(context, key);	2✔
41	if (init) {	2✔
42	if (	1✔
43	init.node.type === "Literal" \|\|	1!
44	init.node.type === "TemplateLiteral"
45	) {
46	return getStringLiteralValue(init.node);	1✔
47	}
48	}
49	}
50	return null;	1✔
51	}
52
53	/**
54	* Gets the string of a given node.
55	*/
56	export function getStringLiteralValue(
57	node: AST.ESLintLiteral \| AST.ESLintTemplateLiteral,
58	): string \| null {
59	if (node.type === "Literal") {	75✔
60	if (node.value == null) {	74✔
61	if ((node as any).bigint != null) {	1!
62	return String((node as any).bigint);	×
63	}
64	}
65	return String(node.value);	74✔
66	}
67	if (node.type === "TemplateLiteral") {	1✔
68	if (node.expressions.length === 0 && node.quasis.length === 1) {	1✔
69	return node.quasis[0].value.cooked;	1✔
70	}
71	}
72	return null;	×
73	}
74
75	/**
76	* Find the variable of a given name.
77	*/
78	function findVariable(
79	context: RuleContext,
80	node: AST.ESLintIdentifier,
81	): Variable \| null {
82	return eslintUtils.findVariable(getScope(context, node), node);	103✔
83	}
84
85	/**
86	* Get the value of a given node if it's a static value.
87	*/
88	export function getStaticValue(
89	context: RuleContext,
90	node: AST.ESLintNode,
91	): { value: any } \| null {
92	return eslintUtils.getStaticValue(node, getScope(context, node));	31✔
93	}
94
95	/**
96	* Find the node that initial value.
97	*/
98	export function findInitNode(
99	context: RuleContext,
100	node: AST.ESLintIdentifier,
101	): { node: AST.ESLintExpression; reads: AST.ESLintIdentifier[] } \| null {
102	const variable = findVariable(context, node);	103✔
103	if (!variable) {	103!
104	return null;	×
105	}
106	if (variable.defs.length === 1) {	103✔
107	const def = variable.defs[0];	96✔
108	if (	96✔
109	def.type === "Variable" &&	267✔
110	def.parent.kind === "const" &&
111	def.node.init
112	) {
113	let init = def.node.init as AST.ESLintExpression;	76✔
114	const reads = variable.references	76✔
115	.filter((ref) => ref.isRead())	364✔
116	.map((ref) => ref.identifier as AST.ESLintIdentifier);	288✔
117	if (init.type === "Identifier") {	76✔
118	const data = findInitNode(context, init);	3✔
119	if (!data) {	3✔
120	return null;	2✔
121	}
122	init = data.node;	1✔
123	reads.push(...data.reads);	1✔
124	}
125
126	return {	74✔
127	node: init,
128	reads,
129	};
130	}
131	}
132	return null;	27✔
133	}
134
135	/**
136	* Gets the scope for the current node
137	*/
138	function getScope(context: RuleContext, currentNode: AST.ESLintNode) {
139	// On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
140	const inner = currentNode.type !== "Program";	134✔
141	const scopeManager = getSourceCode(context).scopeManager;	134✔
142
143	let node: any = currentNode;	134✔
144	for (; node; node = node.parent \|\| null) {	134!
145	const scope = scopeManager.acquire(node, inner);	744✔
146
147	if (scope) {	744✔
148	if (scope.type === "function-expression-name") {	134!
149	return scope.childScopes[0];	×
150	}
151	return scope;	134✔
152	}
153	}
154
155	return scopeManager.scopes[0];	×
156	}

ota-meshi / eslint-plugin-json-schema-validator / 14773577666

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