Add an ESLint rule to prevent the usage of useRef other than for HTML elements. (#2014)
* Add an ESLint rule to prevent the usage of useRef other than for HTML elements Co-authored-by: v1b3m <vibenjamin6@gmail.com> * Bump eslint version and rewrite rule * Fix --------- Co-authored-by: v1b3m <vibenjamin6@gmail.com> Co-authored-by: Charles Bochet <charles@twenty.com>
This commit is contained in:
gitstart-twenty
12
packages/eslint-plugin-twenty-ts/dist/index.js
vendored
12
packages/eslint-plugin-twenty-ts/dist/index.js
vendored
@ -1,12 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
module.exports = {
|
||||
rules: {
|
||||
"effect-components": require("./src/rules/effect-components"),
|
||||
"no-hardcoded-colors": require("./src/rules/no-hardcoded-colors"),
|
||||
"matching-state-variable": require("./src/rules/matching-state-variable"),
|
||||
"sort-css-properties-alphabetically": require("./src/rules/sort-css-properties-alphabetically"),
|
||||
"styled-components-prefixed-with-styled": require("./src/rules/styled-components-prefixed-with-styled"),
|
||||
"component-props-naming": require("./src/rules/component-props-naming"),
|
||||
},
|
||||
};
|
||||
@ -1,66 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator(() => "https://docs.twenty.com/developer/frontend/style-guide#props");
|
||||
const checkPropsTypeName = (node, context, functionName) => {
|
||||
const expectedPropTypeName = `${functionName}Props`;
|
||||
if (/^[A-Z]/.test(functionName)) {
|
||||
node.params.forEach((param) => {
|
||||
var _a, _b;
|
||||
if ((param.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
|
||||
param.type === utils_1.AST_NODE_TYPES.Identifier) &&
|
||||
((_b = (_a = param.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation) === null || _b === void 0 ? void 0 : _b.type) ===
|
||||
utils_1.AST_NODE_TYPES.TSTypeReference &&
|
||||
param.typeAnnotation.typeAnnotation.typeName.type ===
|
||||
utils_1.AST_NODE_TYPES.Identifier) {
|
||||
const { typeName } = param.typeAnnotation.typeAnnotation;
|
||||
const actualPropTypeName = typeName.name;
|
||||
if (actualPropTypeName !== expectedPropTypeName) {
|
||||
context.report({
|
||||
node: param,
|
||||
messageId: "invalidPropsTypeName",
|
||||
data: { expectedPropTypeName, actualPropTypeName },
|
||||
fix: (fixer) => fixer.replaceText(typeName, expectedPropTypeName),
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
const componentPropsNamingRule = createRule({
|
||||
create: (context) => {
|
||||
return {
|
||||
ArrowFunctionExpression: (node) => {
|
||||
var _a, _b;
|
||||
if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
|
||||
node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
|
||||
const functionName = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.name;
|
||||
checkPropsTypeName(node, context, functionName);
|
||||
}
|
||||
},
|
||||
FunctionDeclaration: (node) => {
|
||||
var _a;
|
||||
if ((_a = node.id) === null || _a === void 0 ? void 0 : _a.name) {
|
||||
const functionName = node.id.name;
|
||||
checkPropsTypeName(node, context, functionName);
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
name: "component-props-naming",
|
||||
meta: {
|
||||
type: "problem",
|
||||
docs: {
|
||||
description: "Ensure component props follow naming convention",
|
||||
recommended: "recommended",
|
||||
},
|
||||
fixable: "code",
|
||||
schema: [],
|
||||
messages: {
|
||||
invalidPropsTypeName: "Expected prop type to be '{{ expectedPropTypeName }}' but found '{{ actualPropTypeName }}'",
|
||||
},
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
module.exports = componentPropsNamingRule;
|
||||
exports.default = componentPropsNamingRule;
|
||||
@ -1,96 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://docs.twenty.com`);
|
||||
const checkIsPascalCase = (input) => {
|
||||
const pascalCaseRegex = /^(?:\p{Uppercase_Letter}\p{Letter}*)+$/u;
|
||||
return pascalCaseRegex.test(input);
|
||||
};
|
||||
const effectComponentsRule = createRule({
|
||||
create(context) {
|
||||
const checkThatNodeIsEffectComponent = (node) => {
|
||||
var _a, _b, _c, _d, _e;
|
||||
const isPascalCase = checkIsPascalCase((_b = (_a = node.id) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "");
|
||||
if (!isPascalCase) {
|
||||
return;
|
||||
}
|
||||
const isReturningFragmentOrNull = (
|
||||
// Direct return of JSX fragment, e.g., () => <></>
|
||||
(node.body.type === 'JSXFragment' && node.body.children.length === 0) ||
|
||||
// Direct return of null, e.g., () => null
|
||||
(node.body.type === 'Literal' && node.body.value === null) ||
|
||||
// Return JSX fragment or null from block
|
||||
(node.body.type === 'BlockStatement' &&
|
||||
node.body.body.some(statement => {
|
||||
var _a, _b, _c;
|
||||
return statement.type === 'ReturnStatement' &&
|
||||
(
|
||||
// Empty JSX fragment return, e.g., return <></>;
|
||||
(((_a = statement.argument) === null || _a === void 0 ? void 0 : _a.type) === 'JSXFragment' && statement.argument.children.length === 0) ||
|
||||
// Empty React.Fragment return, e.g., return <React.Fragment></React.Fragment>;
|
||||
(((_b = statement.argument) === null || _b === void 0 ? void 0 : _b.type) === 'JSXElement' &&
|
||||
statement.argument.openingElement.name.type === 'JSXIdentifier' &&
|
||||
statement.argument.openingElement.name.name === 'React.Fragment' &&
|
||||
statement.argument.children.length === 0) ||
|
||||
// Literal null return, e.g., return null;
|
||||
(((_c = statement.argument) === null || _c === void 0 ? void 0 : _c.type) === 'Literal' && statement.argument.value === null));
|
||||
})));
|
||||
const hasEffectSuffix = (_c = node.id) === null || _c === void 0 ? void 0 : _c.name.endsWith("Effect");
|
||||
const hasEffectSuffixButIsNotEffectComponent = hasEffectSuffix && !isReturningFragmentOrNull;
|
||||
const isEffectComponentButDoesNotHaveEffectSuffix = !hasEffectSuffix && isReturningFragmentOrNull;
|
||||
if (isEffectComponentButDoesNotHaveEffectSuffix) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "effectSuffix",
|
||||
data: {
|
||||
componentName: (_d = node.id) === null || _d === void 0 ? void 0 : _d.name,
|
||||
},
|
||||
fix(fixer) {
|
||||
var _a;
|
||||
if (node.id) {
|
||||
return fixer.replaceText(node.id, ((_a = node.id) === null || _a === void 0 ? void 0 : _a.name) + "Effect");
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
}
|
||||
else if (hasEffectSuffixButIsNotEffectComponent) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "noEffectSuffix",
|
||||
data: {
|
||||
componentName: (_e = node.id) === null || _e === void 0 ? void 0 : _e.name,
|
||||
},
|
||||
fix(fixer) {
|
||||
var _a;
|
||||
if (node.id) {
|
||||
return fixer.replaceText(node.id, (_a = node.id) === null || _a === void 0 ? void 0 : _a.name.replace("Effect", ""));
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
}
|
||||
};
|
||||
return {
|
||||
ArrowFunctionExpression: checkThatNodeIsEffectComponent,
|
||||
FunctionDeclaration: checkThatNodeIsEffectComponent,
|
||||
FunctionExpression: checkThatNodeIsEffectComponent,
|
||||
};
|
||||
},
|
||||
name: "effect-components",
|
||||
meta: {
|
||||
docs: {
|
||||
description: "Effect components should end with the Effect suffix. This rule checks only components that are in PascalCase and that return a JSX fragment or null. Any renderProps or camelCase components are ignored.",
|
||||
},
|
||||
messages: {
|
||||
effectSuffix: "Effect component {{ componentName }} should end with the Effect suffix.",
|
||||
noEffectSuffix: "Component {{ componentName }} shouldn't end with the Effect suffix because it doesn't return a JSX fragment or null.",
|
||||
},
|
||||
type: "suggestion",
|
||||
schema: [],
|
||||
fixable: "code",
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
module.exports = effectComponentsRule;
|
||||
exports.default = effectComponentsRule;
|
||||
@ -1,113 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://docs.twenty.com`);
|
||||
const matchingStateVariableRule = createRule({
|
||||
create: (context) => {
|
||||
return {
|
||||
VariableDeclarator(node) {
|
||||
var _a, _b, _c, _d, _e, _f, _g;
|
||||
if (((_a = node === null || node === void 0 ? void 0 : node.init) === null || _a === void 0 ? void 0 : _a.type) === utils_1.AST_NODE_TYPES.CallExpression &&
|
||||
node.init.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
|
||||
[
|
||||
"useRecoilState",
|
||||
"useRecoilFamilyState",
|
||||
"useRecoilSelector",
|
||||
"useRecoilScopedState",
|
||||
"useRecoilScopedFamilyState",
|
||||
"useRecoilScopedSelector",
|
||||
"useRecoilValue",
|
||||
].includes(node.init.callee.name)) {
|
||||
const stateNameBase = ((_c = (_b = node.init.arguments) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.type) === utils_1.AST_NODE_TYPES.Identifier
|
||||
? node.init.arguments[0].name
|
||||
: undefined;
|
||||
if (!stateNameBase) {
|
||||
return;
|
||||
}
|
||||
let expectedVariableNameBase = stateNameBase.replace(/(State|FamilyState|Selector|ScopedState|ScopedFamilyState|ScopedSelector)$/, "");
|
||||
if (node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
|
||||
const actualVariableName = node.id.name;
|
||||
if (actualVariableName !== expectedVariableNameBase) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "invalidVariableName",
|
||||
data: {
|
||||
actual: actualVariableName,
|
||||
expected: expectedVariableNameBase,
|
||||
callee: node.init.callee.name,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.replaceText(node.id, expectedVariableNameBase);
|
||||
},
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
|
||||
const actualVariableName = ((_e = (_d = node.id.elements) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.type) === utils_1.AST_NODE_TYPES.Identifier
|
||||
? node.id.elements[0].name
|
||||
: undefined;
|
||||
if (actualVariableName &&
|
||||
actualVariableName !== expectedVariableNameBase) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "invalidVariableName",
|
||||
data: {
|
||||
actual: actualVariableName,
|
||||
expected: expectedVariableNameBase,
|
||||
callee: node.init.callee.name,
|
||||
},
|
||||
fix(fixer) {
|
||||
if (node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
|
||||
return fixer.replaceText(node.id.elements[0], expectedVariableNameBase);
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (((_g = (_f = node.id.elements) === null || _f === void 0 ? void 0 : _f[1]) === null || _g === void 0 ? void 0 : _g.type) === utils_1.AST_NODE_TYPES.Identifier) {
|
||||
const actualSetterName = node.id.elements[1].name;
|
||||
const expectedSetterName = `set${expectedVariableNameBase
|
||||
.charAt(0)
|
||||
.toUpperCase()}${expectedVariableNameBase.slice(1)}`;
|
||||
if (actualSetterName !== expectedSetterName) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "invalidSetterName",
|
||||
data: {
|
||||
actual: actualSetterName,
|
||||
expected: expectedSetterName,
|
||||
},
|
||||
fix(fixer) {
|
||||
if (node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
|
||||
return fixer.replaceText(node.id.elements[1], expectedSetterName);
|
||||
}
|
||||
return null;
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
name: "recoil-hook-naming",
|
||||
meta: {
|
||||
type: "problem",
|
||||
docs: {
|
||||
description: "Ensure recoil value and setter are named after their atom name",
|
||||
recommended: "recommended",
|
||||
},
|
||||
fixable: "code",
|
||||
schema: [],
|
||||
messages: {
|
||||
invalidVariableName: "Invalid usage of {{hookName}}: the value should be named '{{expectedName}}' but found '{{actualName}}'.",
|
||||
invalidSetterName: "Invalid usage of {{hookName}}: Expected setter '{{expectedName}}' but found '{{actualName}}'.",
|
||||
},
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
module.exports = matchingStateVariableRule;
|
||||
exports.default = matchingStateVariableRule;
|
||||
@ -1,42 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://docs.twenty.com`);
|
||||
const noHardcodedColorsRule = createRule({
|
||||
create(context) {
|
||||
return {
|
||||
TaggedTemplateExpression(node) {
|
||||
if (context.getFilename().endsWith("themes.ts")) {
|
||||
return;
|
||||
}
|
||||
node.quasi.quasis.forEach((quasi) => {
|
||||
const colorRegex = /(?:rgba?\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})(,\s*\d+\.?\d*)?\))|(?:#[0-9a-fA-F]{6})/i;
|
||||
if (colorRegex.test(quasi.value.raw)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "hardcodedColor",
|
||||
data: {
|
||||
color: quasi.value.raw,
|
||||
},
|
||||
});
|
||||
}
|
||||
});
|
||||
},
|
||||
};
|
||||
},
|
||||
name: "no-hardcoded-colors",
|
||||
meta: {
|
||||
docs: {
|
||||
description: "Do not use hardcoded RGBA or Hex colors. Please use a color from the theme file.",
|
||||
},
|
||||
messages: {
|
||||
hardcodedColor: "Hardcoded color {{ color }} found. Please use a color from the theme file.",
|
||||
},
|
||||
type: "suggestion",
|
||||
schema: [],
|
||||
fixable: "code",
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
module.exports = noHardcodedColorsRule;
|
||||
exports.default = noHardcodedColorsRule;
|
||||
@ -1,182 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const postcss_1 = __importDefault(require("postcss"));
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://docs.twenty.com`);
|
||||
const isStyledTagname = (node) => {
|
||||
return ((node.tag.type === "Identifier" && node.tag.name === "css") ||
|
||||
(node.tag.type === "MemberExpression" &&
|
||||
// @ts-ignore
|
||||
node.tag.object.name === "styled") ||
|
||||
(node.tag.type === "CallExpression" &&
|
||||
// @ts-ignore
|
||||
(node.tag.callee.name === "styled" ||
|
||||
// @ts-ignore
|
||||
(node.tag.callee.object &&
|
||||
// @ts-ignore
|
||||
((node.tag.callee.object.callee &&
|
||||
// @ts-ignore
|
||||
node.tag.callee.object.callee.name === "styled") ||
|
||||
// @ts-ignore
|
||||
(node.tag.callee.object.object &&
|
||||
// @ts-ignore
|
||||
node.tag.callee.object.object.name === "styled"))))));
|
||||
};
|
||||
/**
|
||||
* An atomic rule is a rule without nested rules.
|
||||
*/
|
||||
const isValidAtomicRule = (rule) => {
|
||||
const decls = rule.nodes.filter((node) => node.type === "decl");
|
||||
if (decls.length < 0) {
|
||||
return { isValid: true };
|
||||
}
|
||||
for (let i = 1; i < decls.length; i++) {
|
||||
const current = decls[i].prop;
|
||||
const prev = decls[i - 1].prop;
|
||||
if (current < prev) {
|
||||
const loc = {
|
||||
start: {
|
||||
line: decls[i - 1].source.start.line,
|
||||
column: decls[i - 1].source.start.column - 1,
|
||||
},
|
||||
end: {
|
||||
line: decls[i].source.end.line,
|
||||
column: decls[i].source.end.column - 1,
|
||||
},
|
||||
};
|
||||
return { isValid: false, loc };
|
||||
}
|
||||
}
|
||||
return { isValid: true };
|
||||
};
|
||||
const isValidRule = (rule) => {
|
||||
// check each rule recursively
|
||||
const { isValid, loc } = rule.nodes.reduce((map, node) => {
|
||||
return node.type === "rule"
|
||||
? isValidRule(node)
|
||||
: map;
|
||||
}, { isValid: true });
|
||||
// if there is any invalid rule, return result
|
||||
if (!isValid) {
|
||||
return { isValid, loc };
|
||||
}
|
||||
// check declarations
|
||||
return isValidAtomicRule(rule);
|
||||
};
|
||||
const getNodeStyles = (node) => {
|
||||
const [firstQuasi, ...quasis] = node.quasi.quasis;
|
||||
// remove line break added to the first quasi
|
||||
const lineBreakCount = node.quasi.loc.start.line - 1;
|
||||
let styles = `${"\n".repeat(lineBreakCount)}${" ".repeat(node.quasi.loc.start.column + 1)}${firstQuasi.value.raw}`;
|
||||
// replace expression by spaces and line breaks
|
||||
quasis.forEach(({ value, loc }, idx) => {
|
||||
const prevLoc = idx === 0 ? firstQuasi.loc : quasis[idx - 1].loc;
|
||||
const lineBreaksCount = loc.start.line - prevLoc.end.line;
|
||||
const spacesCount = loc.start.line === prevLoc.end.line
|
||||
? loc.start.column - prevLoc.end.column + 2
|
||||
: loc.start.column + 1;
|
||||
styles = `${styles}${" "}${"\n".repeat(lineBreaksCount)}${" ".repeat(spacesCount)}${value.raw}`;
|
||||
});
|
||||
return styles;
|
||||
};
|
||||
const fix = ({ rule, fixer, src, }) => {
|
||||
let fixings = [];
|
||||
// concat fixings recursively
|
||||
rule.nodes.forEach((node) => {
|
||||
if (node.type === "rule") {
|
||||
fixings = [...fixings, ...fix({ rule: node, fixer, src })];
|
||||
}
|
||||
});
|
||||
const declarations = rule.nodes.filter((node) => node.type === "decl");
|
||||
const sortedDeclarations = sortDeclarations(declarations);
|
||||
declarations.forEach((decl, idx) => {
|
||||
if (!areSameDeclarations(decl, sortedDeclarations[idx])) {
|
||||
try {
|
||||
const range = getDeclRange({ decl, src });
|
||||
const sortedDeclText = getDeclText({
|
||||
decl: sortedDeclarations[idx],
|
||||
src,
|
||||
});
|
||||
fixings.push(fixer.removeRange([range.startIdx, range.endIdx + 1]));
|
||||
fixings.push(fixer.insertTextAfterRange([range.startIdx, range.startIdx], sortedDeclText));
|
||||
}
|
||||
catch (e) {
|
||||
console.log(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
return fixings;
|
||||
};
|
||||
const areSameDeclarations = (a, b) => a.source.start.line === b.source.start.line &&
|
||||
a.source.start.column === b.source.start.column;
|
||||
const getDeclRange = ({ decl, src, }) => {
|
||||
const loc = {
|
||||
start: {
|
||||
line: decl.source.start.line,
|
||||
column: decl.source.start.column - 1,
|
||||
},
|
||||
end: {
|
||||
line: decl.source.end.line,
|
||||
column: decl.source.end.column - 1,
|
||||
},
|
||||
};
|
||||
const startIdx = src.getIndexFromLoc(loc.start);
|
||||
const endIdx = src.getIndexFromLoc(loc.end);
|
||||
return { startIdx, endIdx };
|
||||
};
|
||||
const getDeclText = ({ decl, src, }) => {
|
||||
const { startIdx, endIdx } = getDeclRange({ decl, src });
|
||||
return src.getText().substring(startIdx, endIdx + 1);
|
||||
};
|
||||
const sortDeclarations = (declarations) => declarations
|
||||
.slice()
|
||||
.sort((declA, declB) => (declA.prop > declB.prop ? 1 : -1));
|
||||
const sortCssPropertiesAlphabeticallyRule = createRule({
|
||||
create(context) {
|
||||
return {
|
||||
TaggedTemplateExpression(node) {
|
||||
if (isStyledTagname(node)) {
|
||||
try {
|
||||
const root = postcss_1.default.parse(getNodeStyles(node));
|
||||
const { isValid, loc } = isValidRule(root);
|
||||
if (!isValid) {
|
||||
return context.report({
|
||||
node,
|
||||
messageId: "sort-css-properties-alphabetically",
|
||||
loc,
|
||||
fix: (fixer) => fix({
|
||||
// @ts-ignore
|
||||
rule: root,
|
||||
fixer,
|
||||
src: context.getSourceCode(),
|
||||
}),
|
||||
});
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
name: "sort-css-properties-alphabetically",
|
||||
meta: {
|
||||
docs: {
|
||||
description: "Styles are sorted alphabetically.",
|
||||
recommended: "recommended",
|
||||
},
|
||||
messages: {
|
||||
"sort-css-properties-alphabetically": "Declarations should be sorted alphabetically.",
|
||||
},
|
||||
type: "suggestion",
|
||||
schema: [],
|
||||
fixable: "code",
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
module.exports = sortCssPropertiesAlphabeticallyRule;
|
||||
exports.default = sortCssPropertiesAlphabeticallyRule;
|
||||
@ -1,49 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://docs.twenty.com`);
|
||||
const styledComponentsPrefixedWithStyledRule = createRule({
|
||||
create(context) {
|
||||
return {
|
||||
VariableDeclarator: (node) => {
|
||||
const templateExpr = node.init;
|
||||
if ((templateExpr === null || templateExpr === void 0 ? void 0 : templateExpr.type) !== utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
|
||||
return;
|
||||
}
|
||||
const tag = templateExpr.tag;
|
||||
const tagged = tag.type === utils_1.AST_NODE_TYPES.MemberExpression ? tag.object
|
||||
: tag.type === utils_1.AST_NODE_TYPES.CallExpression ? tag.callee
|
||||
: null;
|
||||
if ((tagged === null || tagged === void 0 ? void 0 : tagged.type) === utils_1.AST_NODE_TYPES.Identifier && tagged.name === 'styled') {
|
||||
const variable = node.id;
|
||||
if (variable.name.startsWith('Styled')) {
|
||||
return;
|
||||
}
|
||||
context.report({
|
||||
node,
|
||||
messageId: 'noStyledPrefix',
|
||||
data: {
|
||||
componentName: variable.name
|
||||
}
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
name: 'styled-components-prefixed-with-styled',
|
||||
meta: {
|
||||
type: 'suggestion',
|
||||
docs: {
|
||||
description: 'Warn when StyledComponents are not prefixed with Styled',
|
||||
recommended: "recommended"
|
||||
},
|
||||
messages: {
|
||||
noStyledPrefix: '{{componentName}} is a StyledComponent and is not prefixed with Styled.',
|
||||
},
|
||||
fixable: 'code',
|
||||
schema: [],
|
||||
},
|
||||
defaultOptions: []
|
||||
});
|
||||
module.exports = styledComponentsPrefixedWithStyledRule;
|
||||
exports.default = styledComponentsPrefixedWithStyledRule;
|
||||
@ -1,54 +0,0 @@
|
||||
import { RuleTester } from "@typescript-eslint/rule-tester";
|
||||
|
||||
import componentPropsNamingRule from "../rules/component-props.naming";
|
||||
|
||||
const ruleTester = new RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
ruleTester.run("component-props-naming", componentPropsNamingRule, {
|
||||
valid: [
|
||||
{
|
||||
code: `
|
||||
type MyComponentProps = { id: number; };
|
||||
const MyComponent: React.FC<MyComponentProps> = (props) => <div>{props.id}</div>;
|
||||
`,
|
||||
},
|
||||
{
|
||||
code: `
|
||||
type AnotherComponentProps = { message: string; };
|
||||
export const AnotherComponent: React.FC<AnotherComponentProps> = (props) => <div>{props.message}</div>;
|
||||
`,
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: `
|
||||
type UnmatchedComponentProps = { id: number; };
|
||||
`,
|
||||
errors: [
|
||||
{
|
||||
messageId: "invalidPropsTypeName",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: `
|
||||
type UnmatchedComponentProps = { message: string; };
|
||||
const DifferentComponent: React.FC<UnmatchedComponentProps> = (props) => <div>{props.message}</div>;
|
||||
`,
|
||||
errors: [
|
||||
{
|
||||
messageId: "invalidPropsTypeName",
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -1,87 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const rule_tester_1 = require("@typescript-eslint/rule-tester");
|
||||
const effect_components_1 = __importDefault(require("../rules/effect-components"));
|
||||
const ruleTester = new rule_tester_1.RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
ruleTester.run("effect-components", effect_components_1.default, {
|
||||
valid: [
|
||||
{
|
||||
code: `const TestComponentEffect = () => <></>;`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponent = () => <div></div>;`,
|
||||
},
|
||||
{
|
||||
code: `export const useUpdateEffect = () => null;`,
|
||||
},
|
||||
{
|
||||
code: `export const useUpdateEffect = () => <></>;`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponent = () => <><div></div></>;`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponentEffect = () => null;`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponentEffect = () => {
|
||||
useEffect(() => {}, []);
|
||||
|
||||
return null;
|
||||
}`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponentEffect = () => {
|
||||
useEffect(() => {}, []);
|
||||
|
||||
return <></>;
|
||||
}`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponentEffect = () => {
|
||||
useEffect(() => {}, []);
|
||||
|
||||
return <></>;
|
||||
}`,
|
||||
},
|
||||
{
|
||||
code: `const TestComponentEffect = () => {
|
||||
useEffect(() => {}, []);
|
||||
|
||||
return null;
|
||||
}`,
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: "const TestComponent = () => <></>;",
|
||||
output: 'const TestComponentEffect = () => <></>;',
|
||||
errors: [
|
||||
{
|
||||
messageId: "effectSuffix",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: "const TestComponentEffect = () => <><div></div></>;",
|
||||
output: 'const TestComponent = () => <><div></div></>;',
|
||||
errors: [
|
||||
{
|
||||
messageId: "noEffectSuffix",
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -1,3 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
// Required by typescript-eslint https://typescript-eslint.io/packages/rule-tester#type-aware-testing
|
||||
@ -1,50 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const rule_tester_1 = require("@typescript-eslint/rule-tester");
|
||||
const matching_state_variable_1 = __importDefault(require("../rules/matching-state-variable"));
|
||||
const ruleTester = new rule_tester_1.RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
ruleTester.run('matching-state-variable', matching_state_variable_1.default, {
|
||||
valid: [
|
||||
{
|
||||
code: 'const variable = useRecoilValue(variableState);',
|
||||
},
|
||||
{
|
||||
code: 'const [variable, setVariable] = useRecoilState(variableState);',
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: 'const myValue = useRecoilValue(variableState);',
|
||||
errors: [
|
||||
{
|
||||
messageId: 'invalidVariableName',
|
||||
},
|
||||
],
|
||||
output: 'const variable = useRecoilValue(variableState);',
|
||||
},
|
||||
{
|
||||
code: 'const [myValue, setMyValue] = useRecoilState(variableState);',
|
||||
errors: [
|
||||
{
|
||||
messageId: 'invalidVariableName',
|
||||
},
|
||||
{
|
||||
messageId: 'invalidSetterName',
|
||||
},
|
||||
],
|
||||
output: 'const [variable, setVariable] = useRecoilState(variableState);',
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -1,45 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const rule_tester_1 = require("@typescript-eslint/rule-tester");
|
||||
const no_hardcoded_colors_1 = __importDefault(require("../rules/no-hardcoded-colors"));
|
||||
const ruleTester = new rule_tester_1.RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
ruleTester.run("no-hardcoded-colors", no_hardcoded_colors_1.default, {
|
||||
valid: [
|
||||
{
|
||||
code: "const color = theme.background.secondary;",
|
||||
},
|
||||
{
|
||||
code: 'const color = "#000000";',
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: 'const color = "rgb(154,205,50)";',
|
||||
errors: [
|
||||
{
|
||||
messageId: "hardcodedColor",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: 'const color = "#ADFF2F";',
|
||||
errors: [
|
||||
{
|
||||
messageId: "hardcodedColor",
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -1,3 +0,0 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
// Required by typescript-eslint https://typescript-eslint.io/packages/rule-tester#type-aware-testing
|
||||
@ -1,61 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const rule_tester_1 = require("@typescript-eslint/rule-tester");
|
||||
const sort_css_properties_alphabetically_1 = __importDefault(require("../rules/sort-css-properties-alphabetically"));
|
||||
const ruleTester = new rule_tester_1.RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
ruleTester.run("sort-css-properties-alphabetically", sort_css_properties_alphabetically_1.default, {
|
||||
valid: [
|
||||
{
|
||||
code: 'const style = css`color: red;`;',
|
||||
filename: 'react.tsx',
|
||||
},
|
||||
{
|
||||
code: 'const style = styled.div`background-color: $bgColor;`;',
|
||||
filename: 'react.tsx',
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: 'const style = css`color: #FF0000;`;',
|
||||
filename: 'react.tsx',
|
||||
errors: [
|
||||
{
|
||||
messageId: "sort-css-properties-alphabetically",
|
||||
suggestions: [
|
||||
{
|
||||
messageId: "sort-css-properties-alphabetically",
|
||||
output: 'const style = css`color: red;`;',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: 'const style = styled.div`background-color: $bgColor; color: #FFFFFF;`;',
|
||||
filename: 'react.tsx',
|
||||
errors: [
|
||||
{
|
||||
messageId: "sort-css-properties-alphabetically",
|
||||
suggestions: [
|
||||
{
|
||||
messageId: "sort-css-properties-alphabetically",
|
||||
output: 'const style = styled.div`background-color: $bgColor; color: white;`;',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -1,49 +0,0 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const rule_tester_1 = require("@typescript-eslint/rule-tester");
|
||||
const styled_components_prefixed_with_styled_1 = __importDefault(require("../rules/styled-components-prefixed-with-styled"));
|
||||
const ruleTester = new rule_tester_1.RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
ruleTester.run("styled-components-prefixed-with-styled", styled_components_prefixed_with_styled_1.default, {
|
||||
valid: [
|
||||
{
|
||||
code: 'const StyledButton = styled.button``;',
|
||||
filename: 'react.tsx',
|
||||
},
|
||||
{
|
||||
code: 'const StyledComponent = styled.div``;',
|
||||
filename: 'react.tsx',
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: 'const Button = styled.button``;',
|
||||
filename: 'react.tsx',
|
||||
errors: [
|
||||
{
|
||||
messageId: 'noStyledPrefix',
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: 'const Component = styled.div``;',
|
||||
filename: 'react.tsx',
|
||||
errors: [
|
||||
{
|
||||
messageId: 'noStyledPrefix',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
@ -6,5 +6,6 @@ module.exports = {
|
||||
"sort-css-properties-alphabetically": require("./src/rules/sort-css-properties-alphabetically"),
|
||||
"styled-components-prefixed-with-styled": require("./src/rules/styled-components-prefixed-with-styled"),
|
||||
"component-props-naming": require("./src/rules/component-props-naming"),
|
||||
"no-state-useref": require("./src/rules/no-state-useref"),
|
||||
},
|
||||
};
|
||||
|
||||
68
packages/eslint-plugin-twenty/src/rules/no-state-useref.ts
Normal file
68
packages/eslint-plugin-twenty/src/rules/no-state-useref.ts
Normal file
@ -0,0 +1,68 @@
|
||||
import { ESLintUtils } from "@typescript-eslint/utils";
|
||||
|
||||
const createRule = ESLintUtils.RuleCreator(() => `https://docs.twenty.com`);
|
||||
|
||||
const noStateUseRef = createRule({
|
||||
create: (context) => {
|
||||
return {
|
||||
CallExpression: (node) => {
|
||||
if (
|
||||
node.callee.type !== "Identifier" ||
|
||||
node.callee.name !== "useRef"
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!node.typeArguments || !node.typeArguments.params?.length) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "noStateUseRef",
|
||||
});
|
||||
return;
|
||||
}
|
||||
const typeParam = node.typeArguments.params[0];
|
||||
|
||||
if (typeParam.type !== "TSTypeReference") {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "noStateUseRef",
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeParam.typeName.type !== "Identifier") {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "noStateUseRef",
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
if (!typeParam.typeName.name.match(/^(HTML.*Element|Element)$/)) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "test",
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
name: "no-state-useref",
|
||||
meta: {
|
||||
docs: {
|
||||
description: "Don't use useRef for state management",
|
||||
},
|
||||
messages: {
|
||||
test: "test",
|
||||
noStateUseRef:
|
||||
"Don't use useRef for state management. See https://docs.twenty.com/developer/frontend/best-practices#do-not-use-useref-to-store-state for more details.",
|
||||
},
|
||||
type: "suggestion",
|
||||
schema: [],
|
||||
},
|
||||
defaultOptions: [],
|
||||
});
|
||||
|
||||
module.exports = noStateUseRef;
|
||||
|
||||
export default noStateUseRef;
|
||||
@ -0,0 +1,51 @@
|
||||
import { RuleTester } from "@typescript-eslint/rule-tester";
|
||||
|
||||
import noStateUseRefRule from "../rules/no-state-useref";
|
||||
|
||||
const ruleTester = new RuleTester({
|
||||
parser: "@typescript-eslint/parser",
|
||||
parserOptions: {
|
||||
project: "./tsconfig.json",
|
||||
tsconfigRootDir: __dirname,
|
||||
ecmaFeatures: {
|
||||
jsx: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
ruleTester.run("no-state-useref", noStateUseRefRule, {
|
||||
valid: [
|
||||
{
|
||||
code: "const scrollableRef = useRef<HTMLDivElement>(null);",
|
||||
},
|
||||
{
|
||||
code: "const ref = useRef<HTMLInputElement>(null);",
|
||||
},
|
||||
],
|
||||
invalid: [
|
||||
{
|
||||
code: "const ref = useRef(null);",
|
||||
errors: [
|
||||
{
|
||||
messageId: "noStateUseRef",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: "const ref = useRef<Boolean>(null);",
|
||||
errors: [
|
||||
{
|
||||
messageId: "noStateUseRef",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
code: "const ref = useRef<string>('');",
|
||||
errors: [
|
||||
{
|
||||
messageId: "noStateUseRef",
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
});
|
||||
Reference in New Issue
Block a user