9631741445

Committed 23 Jun 2024 07:28AM UTC coverage: 92.281% (-0.8%) from 93.056%

Build # 9631741445

Build Type

push

github

Committed by

web-flow

Commit Message

fix: VCSSSelector location & use eslint v9 (#358)

* chore: use eslint v9

* fix selector location

* fix

Run Details

1454 of 1669 branches covered (87.12%)

Branch coverage included in aggregate %.

29 of 43 new or added lines in 2 files covered. (67.44%)

5 existing lines in 5 files now uncovered.

2778 of 2917 relevant lines covered (95.23%)

406.21 hits per line

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

93.75

/lib/rules/v-slotted-pseudo-style.ts

import type { ValidStyleContext } from "../styles/context";
import {
  getStyleContexts,
  getCommentDirectivesReporter,
  isValidStyleContext,
} from "../styles/context";
import type { RuleContext, RuleListener } from "../types";
import type { VSlottedPseudo } from "../styles/utils/selectors";
import {
  isVSlottedPseudo,
  isPseudoEmptyArguments,
} from "../styles/utils/selectors";
import { getSourceCode } from "../utils/compat";

export = {
  meta: {
    docs: {
      description: "enforce `:slotted()`/`::v-slotted()` style",
      categories: [
        // TODO: enable in next major version
        // "vue3-recommended"
      ],
      default: "warn",
      url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/v-slotted-pseudo-style.html",
    },
    fixable: "code",
    messages: {
      expectedSlotted: "Expected ':slotted()' instead of '::v-slotted()'.",
      expectedVSlotted: "Expected '::v-slotted()' instead of ':slotted()'.",
    },
    schema: [{ enum: [":slotted", "::v-slotted"] }],
    type: "suggestion",
  },
  create(context: RuleContext): RuleListener {
    const styles = getStyleContexts(context)
      .filter(isValidStyleContext)
      .filter((style) => style.scoped);
    if (!styles.length) {
      return {};
    }
    const expected = (context.options[0] || ":slotted") as
      | ":slotted"
      | "::v-slotted";
    const reporter = getCommentDirectivesReporter(context);

    /**
     * Reports the given node
     * @param {ASTNode} node node to report
     */
    function report(node: VSlottedPseudo) {
      reporter.report({
        node,
        loc: node.loc,
        messageId:
          expected === ":slotted" ? "expectedSlotted" : "expectedVSlotted",
        fix(fixer) {
          const nodeText = getSourceCode(context).text.slice(...node.range);
          return fixer.replaceTextRange(
            node.range,
            nodeText.replace(
              /^(\s*)(?::slotted|::v-slotted)(\s*\()/u,
              (_, prefix: string, suffix: string) =>
                `${prefix}${expected}${suffix}`,
            ),
          );
        },
      });
    }

    /**
     * Verify the node
     */
    function verifyNode(node: VSlottedPseudo) {
      if (node.value === expected) {
        return;
      }

      report(node);
    }

    /**
     * Verify the style
     */
    function verify(style: ValidStyleContext) {
      style.traverseSelectorNodes({
        enterNode(node) {
          if (isVSlottedPseudo(node) && !isPseudoEmptyArguments(node)) {
            verifyNode(node);
          }
        },
      });
    }

    return {
      "Program:exit"() {
        for (const style of styles) {
          verify(style);
        }
      },
    };
  },
};

1	import type { ValidStyleContext } from "../styles/context";
2	import {	1✔
3	getStyleContexts,
4	getCommentDirectivesReporter,
5	isValidStyleContext,
6	} from "../styles/context";
7	import type { RuleContext, RuleListener } from "../types";
8	import type { VSlottedPseudo } from "../styles/utils/selectors";
9	import {	1✔
10	isVSlottedPseudo,
11	isPseudoEmptyArguments,
12	} from "../styles/utils/selectors";
13	import { getSourceCode } from "../utils/compat";	1✔
14
15	export = {	1✔
16	meta: {
17	docs: {
18	description: "enforce `:slotted()`/`::v-slotted()` style",
19	categories: [
20	// TODO: enable in next major version
21	// "vue3-recommended"
22	],
23	default: "warn",
24	url: "https://future-architect.github.io/eslint-plugin-vue-scoped-css/rules/v-slotted-pseudo-style.html",
25	},
26	fixable: "code",
27	messages: {
28	expectedSlotted: "Expected ':slotted()' instead of '::v-slotted()'.",
29	expectedVSlotted: "Expected '::v-slotted()' instead of ':slotted()'.",
30	},
31	schema: [{ enum: [":slotted", "::v-slotted"] }],
32	type: "suggestion",
33	},
34	create(context: RuleContext): RuleListener {
35	const styles = getStyleContexts(context)	10✔
36	.filter(isValidStyleContext)
37	.filter((style) => style.scoped);	10✔
38	if (!styles.length) {	10!
UNCOV 39	return {};	×
40	}
41	const expected = (context.options[0] \|\| ":slotted") as	10✔
42	\| ":slotted"
43	\| "::v-slotted";
44	const reporter = getCommentDirectivesReporter(context);	10✔
45
46	/**
47	* Reports the given node
48	* @param {ASTNode} node node to report
49	*/
50	function report(node: VSlottedPseudo) {
51	reporter.report({	3✔
52	node,
53	loc: node.loc,
54	messageId:
55	expected === ":slotted" ? "expectedSlotted" : "expectedVSlotted",	3✔
56	fix(fixer) {
57	const nodeText = getSourceCode(context).text.slice(...node.range);	3✔
58	return fixer.replaceTextRange(	3✔
59	node.range,
60	nodeText.replace(
61	/^(\s)(?::slotted\|::v-slotted)(\s\()/u,
62	(_, prefix: string, suffix: string) =>
63	`${prefix}${expected}${suffix}`,	3✔
64	),
65	);
66	},
67	});
68	}
69
70	/**
71	* Verify the node
72	*/
73	function verifyNode(node: VSlottedPseudo) {
74	if (node.value === expected) {	9✔
75	return;	6✔
76	}
77
78	report(node);	3✔
79	}
80
81	/**
82	* Verify the style
83	*/
84	function verify(style: ValidStyleContext) {
85	style.traverseSelectorNodes({	10✔
86	enterNode(node) {
87	if (isVSlottedPseudo(node) && !isPseudoEmptyArguments(node)) {	60✔
88	verifyNode(node);	9✔
89	}
90	},
91	});
92	}
93
94	return {	10✔
95	"Program:exit"() {
96	for (const style of styles) {	10✔
97	verify(style);	10✔
98	}
99	},
100	};
101	},
102	};

future-architect / eslint-plugin-vue-scoped-css / 9631741445

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