@fluid-topics/ft-eslint 1.3.0

package/build/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { ESLint } from "eslint";
+declare const plugin: ESLint.Plugin;
+export default plugin;

package/build/plugin.js

@@ -0,0 +1,20 @@
+import { quotedAttributesRule } from "./rules/quoted-attributes";
+import { typographyVariantRule } from "./rules/typography-variant";
+import { interfaceNoCommaRule } from "./rules/interface-no-commas";
+const plugin = {
+    rules: {
+        "quoted-attributes": quotedAttributesRule,
+        "typography-variant": typographyVariantRule,
+        "interface-no-commas": interfaceNoCommaRule,
+    },
+    configs: {
+        recommended: {
+            rules: {
+                "ft/quoted-attributes": "error",
+                "ft/typography-variant": "warn",
+                "ft/interface-no-commas": "error",
+            },
+        },
+    },
+};
+export default plugin;

package/build/rules/interface-no-commas.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "eslint";
+export declare const interfaceNoCommaRule: Rule.RuleModule;

package/build/rules/interface-no-commas.js

@@ -0,0 +1,33 @@
+export const interfaceNoCommaRule = {
+    meta: {
+        docs: {
+            description: "Enforces that interfaces declarations do not use commas",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            forbiddenComma: "Commas are not allowed in interfaces declarations",
+        },
+    },
+    create(context) {
+        return {
+            TSInterfaceDeclaration(node) {
+                for (const element of node.body.body) {
+                    if (element.type !== "TSPropertySignature") {
+                        continue;
+                    }
+                    const property = element;
+                    const lastToken = context.sourceCode.getLastToken(property);
+                    if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.type) === "Punctuator" && lastToken.value === ",") {
+                        context.report({
+                            loc: lastToken.loc,
+                            messageId: "forbiddenComma",
+                            fix: fixer => fixer.remove(lastToken),
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/build/rules/quoted-attributes.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "eslint";
+export declare const quotedAttributesRule: Rule.RuleModule;

package/build/rules/quoted-attributes.js

@@ -0,0 +1,84 @@
+/* Inspiried by lit/quoted-expressions */
+export const quotedAttributesRule = {
+    meta: {
+        docs: {
+            description: "Enforces the presence or absence of quotes around expressions",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            alwaysQuote: "Attributes must be quoted inside templates " +
+                " (e.g. `foo=\"${bar}\"`)",
+            neverQuote: "Properties, events and booleans must not be quoted inside templates " +
+                " (e.g. `.foo=${bar}`)",
+        },
+    },
+    create(context) {
+        const quotePattern = /=(["'])?$/;
+        const attributePattern = /[?@.]\w+=["']?$/;
+        function addQuotes(previousQuasi, nextQuasi) {
+            return (fixer) => {
+                if (!previousQuasi.range || !nextQuasi.range) {
+                    return [];
+                }
+                return [
+                    fixer.insertTextAfterRange([previousQuasi.range[0], previousQuasi.range[1] - 2], "\""),
+                    fixer.insertTextBeforeRange([nextQuasi.range[0] + 1, nextQuasi.range[1]], "\""),
+                ];
+            };
+        }
+        function removeQuotes(previousQuasi, nextQuasi) {
+            return (fixer) => {
+                if (!previousQuasi.range || !nextQuasi.range) {
+                    return [];
+                }
+                return [
+                    fixer.removeRange([
+                        previousQuasi.range[1] - 3,
+                        previousQuasi.range[1] - 2,
+                    ]),
+                    fixer.removeRange([
+                        nextQuasi.range[0] + 1,
+                        nextQuasi.range[0] + 2,
+                    ]),
+                ];
+            };
+        }
+        return {
+            TaggedTemplateExpression: (node) => {
+                if (node.type !== "TaggedTemplateExpression"
+                    || node.tag.type !== "Identifier"
+                    || node.tag.name !== "html") {
+                    return;
+                }
+                for (let i = 0; i < node.quasi.expressions.length; i++) {
+                    const expression = node.quasi.expressions[i];
+                    const previousQuasi = node.quasi.quasis[i];
+                    const nextQuasi = node.quasi.quasis[i + 1];
+                    const quoteMatch = previousQuasi.value.raw.match(quotePattern);
+                    if (!quoteMatch) { // we are not at a `foo=` token
+                        continue;
+                    }
+                    const needQuote = previousQuasi.value.raw.match(attributePattern) === null;
+                    const hasStartQuote = quoteMatch[1] !== undefined;
+                    const isQuoted = hasStartQuote && nextQuasi.value.raw.startsWith(quoteMatch[1]);
+                    if (needQuote && !hasStartQuote) {
+                        context.report({
+                            node: expression,
+                            messageId: "alwaysQuote",
+                            fix: addQuotes(previousQuasi, nextQuasi),
+                        });
+                    }
+                    if (!needQuote && isQuoted) {
+                        context.report({
+                            node: expression,
+                            messageId: "neverQuote",
+                            fix: removeQuotes(previousQuasi, nextQuasi),
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/build/rules/typography-variant.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from "eslint";
+export declare const typographyVariantRule: Rule.RuleModule;

package/build/rules/typography-variant.js

@@ -0,0 +1,49 @@
+import { TemplateAnalyzer } from "eslint-plugin-lit/lib/template-analyzer";
+import { isExpressionPlaceholder } from "eslint-plugin-lit/lib/util";
+export const typographyVariantRule = {
+    meta: {
+        docs: {
+            description: "Enforces that variant attribute uses enum values",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            mandatoryVariant: "<ft-typography> must have a variant attribute",
+            variantUsesEnum: "variant attribute must use an enum value " +
+                " (e.g. `variant=\"${ FtTypographyVariants.title1 }\"`)",
+        },
+    },
+    create(context) {
+        return {
+            TaggedTemplateExpression: (node) => {
+                if (node.type !== "TaggedTemplateExpression"
+                    || node.tag.type !== "Identifier"
+                    || node.tag.name !== "html") {
+                    return;
+                }
+                const analyzer = TemplateAnalyzer.create(node);
+                analyzer.traverse({
+                    enterElement: (element) => {
+                        if (element.tagName === "ft-typography") {
+                            if (!("variant" in element.attribs)) {
+                                const loc = analyzer.resolveLocation(element.sourceCodeLocation, context.sourceCode);
+                                context.report({
+                                    loc,
+                                    messageId: "mandatoryVariant",
+                                });
+                                return;
+                            }
+                            if (!isExpressionPlaceholder(element.attribs["variant"])) {
+                                const loc = analyzer.getLocationForAttribute(element, "variant", context.sourceCode);
+                                context.report({
+                                    loc,
+                                    messageId: "variantUsesEnum",
+                                });
+                            }
+                        }
+                    },
+                });
+            },
+        };
+    },
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@fluid-topics/ft-eslint",
+    "version": "1.3.0",
+    "description": "ESlint rules for web components",
+    "keywords": [
+        "Lit"
+    ],
+    "author": "Fluid Topics <devtopics@antidot.net>",
+    "license": "ISC",
+    "main": "build/index.js",
+    "web": "build/ft-eslint.min.js",
+    "typings": "build/index",
+    "files": [
+        "build/**/*.js",
+        "build/**/*.ts"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "ssh://git@scm.mrs.antidot.net:2222/fluidtopics/ft-web-components.git"
+    },
+    "dependencies": {
+        "lit": "3.1.0"
+    },
+    "gitHead": "cc982effbf27c0483e03961ad450fd2057a108b2"
+}