@orion.ui/orion-linter 1.0.0

package/dist/rules/get-set-adjacent.js

@@ -0,0 +1,154 @@
+export default {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description:
+        'Ensure getters are grouped, get/set pairs are adjacent, and spacing is consistent.',
+		},
+		fixable: 'code',
+		messages: {
+			adjacent:
+        'Getter and setter must be ordered (get before set) and spaced correctly.',
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.getSourceCode();
+
+		const isGetter = node =>
+			node.type === 'MethodDefinition' && node.kind === 'get';
+
+		const nameOf = (node) => {
+			if (!node || !node.key) return null;
+			if (node.key.type === 'Identifier') return node.key.name;
+			if (node.key.type === 'Literal') return String(node.key.value);
+			return null;
+		};
+
+		const isOneLiner = (method) => {
+			const body = method?.value?.body;
+			if (!body || body.type !== 'BlockStatement') return false;
+			return body.loc.start.line === body.loc.end.line;
+		};
+
+		return {
+			ClassBody(node) {
+				const members = node.body;
+
+				const firstGetterIndex = members.findIndex(isGetter);
+				if (firstGetterIndex === -1) return;
+
+				const blockToReorder = members.slice(firstGetterIndex);
+
+				const text = sourceCode.getText();
+				const eol = text.includes('\r\n') ? '\r\n' : '\n';
+
+				// Separate into getters, pairs, others
+				const getters = [];
+				const pairs = [];
+				const others = [];
+				const setterMap = {};
+
+				blockToReorder.forEach((member) => {
+					if (member.type === 'MethodDefinition') {
+						const name = nameOf(member);
+						if (member.kind === 'get') {
+							const setter = setterMap[name];
+							if (setter) {
+								pairs.push(member, setter);
+								delete setterMap[name];
+							}
+							else getters.push(member);
+						}
+						else if (member.kind === 'set') {
+							const getter = getters.find(g => nameOf(g) === name);
+							if (getter) {
+								pairs.push(getter, member);
+								getters.splice(getters.indexOf(getter), 1);
+							}
+							else setterMap[name] = member;
+						}
+						else {
+							others.push(member);
+						}
+					}
+					else {
+						others.push(member);
+					}
+				});
+
+				// Add remaining setters
+				Object.values(setterMap).forEach(s => others.push(s));
+
+				// Build text with correct indentation + spacing
+				const formatBlock = (list, isPairBlock = false) => {
+					if (!list.length) return '';
+					let text = sourceCode.getText(list[0]);
+					for (let i = 1; i < list.length; i++) {
+						const prev = list[i - 1];
+						const current = list[i];
+
+						if (isPairBlock) {
+							// Inside a pairs block:
+							// - Between a setter and the next getter (new pair): 2 line breaks
+							// - Between a getter and its setter: 2 line breaks if getter is multi-line, otherwise 1
+							if (prev.kind === 'set' && current.kind === 'get') {
+								text += eol + eol + '\t' + sourceCode.getText(current);
+							}
+							else if (prev.kind === 'get' && current.kind === 'set') {
+								const getterOneLiner = isOneLiner(prev);
+								const neededBlanks = getterOneLiner ? 1 : 2;
+								text += eol.repeat(neededBlanks) + '\t' + sourceCode.getText(current);
+							}
+							else {
+								text += eol + '\t' + sourceCode.getText(current);
+							}
+						}
+						else {
+							// For standalone getters: normal behavior (1 or 2 breaks depending on one-liner)
+							const prevOneLiner = isOneLiner(prev);
+							const neededBlanks = prevOneLiner ? 1 : 2;
+							text += eol.repeat(neededBlanks) + '\t' + sourceCode.getText(current);
+						}
+					}
+					return text;
+				};
+
+				const firstToken = blockToReorder[0];
+				const lastToken = blockToReorder[blockToReorder.length - 1];
+
+				const newText = formatBlock(getters)
+					+ (getters.length && pairs.length ? eol + eol + '\t' : '')
+					+ formatBlock(pairs, true)
+					+ (others.length ? eol + eol + '\t' : '')
+					+ formatBlock(others);
+
+				// Compare structure + spacing (without trim to detect spacing differences)
+				const currentText = sourceCode.text.slice(
+					firstToken.range[0],
+					lastToken.range[1],
+				);
+				if (currentText === newText) return;
+				context.report({
+					node: getters[0] || pairs[0],
+					messageId: 'adjacent',
+					loc: {
+						start: {
+							line: (getters[0] || pairs[0])?.loc.start.line,
+							column: (getters[0] || pairs[0])?.loc.start.column,
+						},
+						end: {
+							line: (pairs[pairs.length - 1] || getters[getters.length - 1])?.loc.end.line,
+							column: (pairs[pairs.length - 1] || getters[getters.length - 1])?.loc.end.column,
+						},
+					},
+					fix: fixer =>
+						fixer.replaceTextRange(
+							[firstToken.range[0], lastToken.range[1]],
+							newText,
+						),
+				});
+			},
+		};
+	},
+};

package/dist/rules/get-set-one-liner.js

@@ -0,0 +1,156 @@
+export default {
+	meta: {
+		type: 'suggestion',
+		docs: { description: 'Enforce one-line getters and setters when they contain a single simple statement.' },
+		fixable: 'code',
+		messages: {
+			getterOneLiner: 'Getter body can be inlined to a one-liner.',
+			setterOneLiner: 'Setter body can be inlined to a one-liner.',
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.getSourceCode();
+
+		const hasInnerComments = (block) => {
+			if (!block) return false;
+
+			// 1) Dedicated API if available
+			if (typeof sourceCode.getCommentsInside === 'function') {
+				const comments = sourceCode.getCommentsInside(block) || [];
+				if (comments.length > 0) return true;
+			}
+
+			// 2) Tokens with includeComments
+			try {
+				const tokensWithComments = sourceCode.getTokens(block, { includeComments: true }) || [];
+				// Comment tokens usually have type 'Block' or 'Line'
+				if (tokensWithComments.some(t => t.type === 'Block' || t.type === 'Line')) {
+					return true;
+				}
+			}
+			catch {
+				// ignore
+			}
+
+			// 3) Fallback via ranges + getAllComments
+			const [start, end] = block.range || [];
+			const allComments = typeof sourceCode.getAllComments === 'function'
+				? (sourceCode.getAllComments() || [])
+				: [];
+
+			if (start != null && end != null && Array.isArray(allComments)) {
+				if (allComments.some(c => c.range && c.range[0] > start && c.range[1] < end)) {
+					return true;
+				}
+			}
+
+			// 4) Textual check inside braces
+			try {
+				const bodyText = sourceCode.getText(block) || '';
+				// Remove only the 1st and last braces
+				const innerText = bodyText.length >= 2 ? bodyText.slice(1, -1) : '';
+				// Detect // or /* */ even if parser doesn't expose comments
+				if (/\/\/|\/\*/.test(innerText)) {
+					return true;
+				}
+			}
+			catch {
+				// ignore
+			}
+
+			// 5) No comments detected
+			return false;
+		};
+
+		return {
+			MethodDefinition(node) {
+				if (node.kind !== 'get' && node.kind !== 'set') return;
+				const fn = node.value;
+				const body = fn && fn.body;
+				if (!body || body.type !== 'BlockStatement') return;
+				const statements = body.body || [];
+				if (statements.length !== 1) return;
+
+				// Already a one-liner? -> ignore
+				const open = sourceCode.getFirstToken(body);
+				const close = sourceCode.getLastToken(body);
+				if (open && close) {
+					const between = sourceCode.text.slice(open.range[1], close.range[0]);
+					if (!/[\r\n]/.test(between)) return;
+				}
+				else if (body.loc && body.loc.start.line === body.loc.end.line) {
+					return;
+				}
+
+				// Contains comments? -> ignore rule and don't propose fix
+				if (hasInnerComments(body)) return;
+
+				const stmt = statements[0];
+
+				if (node.kind === 'get') {
+					if (stmt.type !== 'ReturnStatement' || !stmt.argument) return;
+
+					// Check if returned expression is on a single line
+					const arg = stmt.argument;
+					if (arg.loc && arg.loc.start.line !== arg.loc.end.line) {
+						// Returned expression is on multiple lines -> ignore
+						return;
+					}
+
+					const argText = sourceCode.getText(stmt.argument);
+
+					// return of an object array -> don't propose fix
+					if (argText.includes('[') && argText.includes('{')) return;
+					context.report({
+						node,
+						messageId: 'getterOneLiner',
+						fix(fixer) {
+							if (hasInnerComments(body)) return null;
+							const newBody = `{ return ${argText}; }`;
+							const openBrace = sourceCode.getFirstToken(body);
+							const prevToken = openBrace ? sourceCode.getTokenBefore(openBrace, { includeComments: false }) : null;
+							// Replace in one go: (single) space + block
+							if (prevToken && body.range) {
+								return fixer.replaceTextRange([prevToken.range[1], body.range[1]], ' ' + newBody);
+							}
+							return fixer.replaceText(body, newBody);
+						},
+					});
+				}
+				else {
+					if (stmt.type !== 'ExpressionStatement') return;
+
+					// Check if expression is on a single line
+					const expr = stmt.expression;
+					if (expr && expr.loc && expr.loc.start.line !== expr.loc.end.line) {
+						// Expression is on multiple lines -> ignore
+						return;
+					}
+
+					const stmtText = sourceCode.getText(stmt).replace(/\s*$/, '');
+					// set of an object array -> don't propose fix
+					if (stmtText.includes('[') && stmtText.includes('{')) return;
+					if (stmtText.length > 120) return;
+					context.report({
+						node,
+						messageId: 'setterOneLiner',
+						fix(fixer) {
+							if (hasInnerComments(body)) return null;
+							const hasSemi = /;\s*$/.test(stmtText);
+							const finalStmt = hasSemi ? stmtText : `${stmtText};`;
+							const newBody = `{ ${finalStmt} }`;
+							const openBrace = sourceCode.getFirstToken(body);
+							const prevToken = openBrace ? sourceCode.getTokenBefore(openBrace, { includeComments: false }) : null;
+							// Replace in one go: (single) space + block
+							if (prevToken && body.range) {
+								return fixer.replaceTextRange([prevToken.range[1], body.range[1]], ' ' + newBody);
+							}
+							return fixer.replaceText(body, newBody);
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/dist/rules/no-api-in-entity.js

@@ -0,0 +1,32 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that no API calls are made from *Entity.ts` },
+	},
+
+	create: function (context) {
+		return {
+			ImportDeclaration(node) {
+				const fileName = context.getPhysicalFilename().split('/').reverse()[0];
+				const fileIsEntity = /Entity\.ts$/.test(fileName);
+
+				if (!fileIsEntity) return;
+
+				// const entityName = fileName.replace('Entity.ts', '');
+				const importValue = node.source.value;
+				const importIsApi = /\/api\//.test(importValue);
+
+				if (!importIsApi) return;
+
+				const apiName = importValue.split('/').reverse()[0];
+
+				context.report({
+					node,
+					message: `Oops !
+We should not use any API in *Entity.ts.
+Use \`${apiName}\` in corresponding Service or create it.`,
+				});
+			},
+		};
+	},
+};

package/dist/rules/no-api-in-setup.js

@@ -0,0 +1,31 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that no API calls are made from *Setup(Service)?.ts` },
+	},
+
+	create: function (context) {
+		return {
+			ImportDeclaration(node) {
+				const fileName = context.getPhysicalFilename().split('/').reverse()[0];
+				const fileIsEntity = /Setup(Service)?\.ts$/.test(fileName);
+
+				if (!fileIsEntity) return;
+
+				const importValue = node.source.value;
+				const importIsApi = /\/api\//.test(importValue);
+
+				if (!importIsApi) return;
+
+				const apiName = importValue.split('/').reverse()[0];
+
+				context.report({
+					node,
+					message: `Oops !
+We should not use any API in Setup.
+Use \`${apiName}\` in corresponding Service or create it.`,
+				});
+			},
+		};
+	},
+};

package/dist/rules/no-entity-in-service.js

@@ -0,0 +1,31 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that no Entity are imported in *Service.ts (except for typing)` },
+	},
+
+	create: function (context) {
+		return {
+			ImportDeclaration(node) {
+				const fileName = context.getPhysicalFilename().split('/').reverse()[0];
+				const fileIsService = /(?<!Setup)Service\.ts$/.test(fileName);
+
+				if (!fileIsService) return;
+
+				// const serviceName = fileName.replace('Service.ts', '');
+
+				const importValue = node.source.value;
+				const importIsEntity = /\/entity\//.test(importValue);
+
+				if (!importIsEntity || node.source.parent.importKind === 'type') return;
+
+				context.report({
+					node,
+					message: `Oops !
+We should not import any Entity in *Service.ts to avoid circular references.
+If it's a type import, replace 'import' with 'import type'.`,
+				});
+			},
+		};
+	},
+};

package/dist/rules/no-export-type-in-ts.js

@@ -0,0 +1,36 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that no types are exported in simple .ts files (place them in shims-*.d.ts)` },
+	},
+
+	create: function (context) {
+		return {
+			ExportNamedDeclaration(node) {
+				const fileName = context.getPhysicalFilename().split('/').reverse()[0];
+				const fileIsDts = /\.d\.ts$/.test(fileName);
+
+				if (fileIsDts) return;
+				if (!node.declaration) return;
+				if (node.declaration.id?.name.endsWith('Emits')) return;
+				if (node.declaration.id?.name.endsWith('Props')) return;
+				// if (/^T[A-Z]+/.test(node.declaration.id?.name)) return;
+
+				const isTsTypeExport = node.declaration.type === 'TSTypeAliasDeclaration';
+
+				if (!isTsTypeExport) return;
+
+				const exportName = node.declaration.id.name;
+
+				context.report({
+					node,
+					message: `Oops !
+We should declare non-Emits types in shims-*.d.ts to avoid types import all around the application.
+Move \`${exportName}\` type declaration in either :
+• src/shims-armado.d.ts (types métiers)
+• src/shims-app.d.ts (types globaux)`,
+				});
+			},
+		};
+	},
+};

package/dist/rules/popables-are-readonly.js

@@ -0,0 +1,52 @@
+function getClassProperties(classNode) {
+	return classNode.body.body.filter(x => x.type === 'PropertyDefinition');
+}
+
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that popables declared in Setup are readonly` },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			ClassDeclaration(node) {
+				function getRefsDeclarations(classNode) {
+					const popableRegex = /^\w*\??:\s*Orion(Aside|Modal)/;
+					return getClassProperties(classNode)
+						.filter(propertyNode => popableRegex.test(sourceCode.getText(propertyNode)))
+						.map(propertyNode => ({
+							node: propertyNode,
+							name: propertyNode.key.name,
+							readonly: propertyNode.readonly,
+						}));
+				}
+
+				getRefsDeclarations(node).forEach((propertyNode) => {
+					const messages = [];
+					const nameIsMissingUnderscore = propertyNode.name.charAt(0) !== '_';
+
+					if (!nameIsMissingUnderscore && propertyNode.readonly) return;
+
+					if (nameIsMissingUnderscore) messages.push(`Popable reference name should begin with '_'.`);
+					if (!propertyNode.readonly) messages.push(`Popable reference should be \`readonly\`.`);
+
+					context.report({
+						node: propertyNode.node,
+						message: `Oops !
+${messages.join('\n')}`,
+						fix: (fixer) => {
+							return fixer.replaceTextRange(
+								propertyNode.node.range,
+								sourceCode.getText(propertyNode.node).replace(/^((readonly)?\s?_*)(.*)/, 'readonly _$3'),
+							);
+						},
+					});
+				});
+			},
+		};
+	},
+};

package/dist/rules/private-property-if-only-in-template.js

@@ -0,0 +1,192 @@
+import fs from 'fs';
+import path from 'path';
+
+export default {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description:
+        'Ensure that properties only used in the setup are private',
+		},
+		fixable: 'code',
+	},
+
+	create(context) {
+		const currentFileName = context.getFilename();
+		const index = currentFileName.endsWith('SetupService.ts')
+			? currentFileName.indexOf('SetupService.ts')
+			: currentFileName.indexOf('Setup.ts');
+		const vueFileName = currentFileName.substring(0, index) + '.vue';
+
+		if (!fs.existsSync(vueFileName)) {
+			return {};
+		}
+
+		const vueSourceFile = fs.readFileSync(vueFileName, 'utf8');
+		const sourceCode = context.getSourceCode();
+
+		// Function to check if a property is declared in the parent class
+		// Returns { isAbstract: boolean, existsInParent: boolean }
+		const checkPropertyInParent = (propertyName, node) => {
+			// Get parent class if it exists
+			if (!node.parent || !node.parent.superClass) {
+				return { isAbstract: false, existsInParent: false };
+			}
+
+			// Handle generic classes: BaseClass<T> -> extract just BaseClass
+			const superClassName = node.parent.superClass.name || (node.parent.superClass.callee && node.parent.superClass.callee.name);
+			if (!superClassName) {
+				return { isAbstract: false, existsInParent: false };
+			}
+
+			// Look for parent class import
+			const imports = sourceCode.ast.body.filter(n => n.type === 'ImportDeclaration');
+			let parentFilePath = null;
+
+			for (const imp of imports) {
+				const defaultImport = imp.specifiers.find(s => s.type === 'ImportDefaultSpecifier');
+				if (defaultImport && defaultImport.local.name === superClassName) {
+					// Get path of imported file
+					const importPath = imp.source.value;
+					const currentDir = currentFileName.substring(0, currentFileName.lastIndexOf('/'));
+
+					// Resolve relative path - normalize path
+					if (importPath.startsWith('./') || importPath.startsWith('../')) {
+						parentFilePath = path.resolve(currentDir, importPath + '.ts');
+					}
+					else if (importPath.startsWith('@/')) {
+						// Handle @ alias pointing to src/
+						const srcDir = currentFileName.substring(0, currentFileName.indexOf('/src/') + 4);
+						const relativePath = importPath.substring(2); // remove '@/'
+						parentFilePath = path.join(srcDir, relativePath + '.ts');
+					}
+					break;
+				}
+			}
+
+			if (!parentFilePath || !fs.existsSync(parentFilePath)) {
+				return { isAbstract: false, existsInParent: false };
+			}
+
+			// Recursive function to check property throughout the hierarchy
+			const checkInFile = (filePath, propName) => {
+				try {
+					const parentSource = fs.readFileSync(filePath, 'utf8');
+
+					// Check if it's abstract
+					// Regex handling: abstract filterService, abstract get listItemType(), etc.
+					const abstractRegex = new RegExp(`abstract\\s+(public\\s+|protected\\s+|private\\s+)?(get\\s+|readonly\\s+)?${propName}\\s*[;:(]`, 'gm');
+					if (abstractRegex.test(parentSource)) {
+						return { isAbstract: true, existsInParent: true };
+					}
+
+					// Check if property/method exists (public, protected or readonly)
+					// Patterns: get propName(), propName =, propName:, readonly propName
+					// Includes access modifiers: public, protected, private
+					// Pattern starts with whitespace or line start to avoid false positives
+					const existsRegex = new RegExp(`(^|\\s)(public\\s+|protected\\s+|private\\s+)?(get\\s+|readonly\\s+)?${propName}\\s*[=:(]`, 'gm');
+					if (existsRegex.test(parentSource)) {
+						return { isAbstract: false, existsInParent: true };
+					}
+
+					// If not found, check parent class of this file
+					// Regex must match extends after generics closure > or after class name
+					// To avoid matching generic constraints like "T extends SomeType"
+					const extendsMatch = parentSource.match(/(?:>\s+|\bclass\s+\w+(?:<[^>]+>)?\s+)extends\s+(\w+)/);
+					if (extendsMatch) {
+						const parentClassName = extendsMatch[1];
+						const parentImportMatch = parentSource.match(new RegExp(`import\\s+${parentClassName}\\s+from\\s+['"]([^'"]+)['"]`));
+						if (parentImportMatch) {
+							const parentImportPath = parentImportMatch[1];
+							const parentDir = filePath.substring(0, filePath.lastIndexOf('/'));
+							let grandParentFilePath;
+
+							if (parentImportPath.startsWith('./') || parentImportPath.startsWith('../')) {
+								grandParentFilePath = path.resolve(parentDir, parentImportPath + '.ts');
+							}
+							else if (parentImportPath.startsWith('@/')) {
+								// Handle @ alias pointing to src/
+								const srcDir = filePath.substring(0, filePath.indexOf('/src/') + 4);
+								const relativePath = parentImportPath.substring(2); // remove '@/'
+								grandParentFilePath = path.join(srcDir, relativePath + '.ts');
+							}
+
+							if (grandParentFilePath && fs.existsSync(grandParentFilePath)) {
+								return checkInFile(grandParentFilePath, propName);
+							}
+						}
+					}
+
+					return { isAbstract: false, existsInParent: false };
+				}
+				catch (error) {
+					return { isAbstract: false, existsInParent: false };
+				}
+			};
+
+			return checkInFile(parentFilePath, propertyName);
+		};
+
+		return {
+			ClassBody(node) {
+				const members = node.body;
+
+				const properties = [];
+
+				for (const member of members) {
+					// Handle PropertyDefinition (properties) and MethodDefinition (methods/getters)
+					if (member.type === 'PropertyDefinition' || member.type === 'MethodDefinition') {
+						if (member.key.type === 'Identifier') {
+							// ignore defaultProps, state, constructor
+							if (['defaultProps', 'state', 'constructor'].includes(member.key.name)) continue;
+
+							properties.push({
+								name: member.key.name,
+								isPrivate: member.accessibility === 'private' || member.accessibility === 'protected',
+								inError: false,
+								member: member,
+								type: member.type,
+							});
+						}
+					}
+				}
+
+				for (const prop of properties) {
+					const parentCheck = checkPropertyInParent(prop.name, node);
+
+					// Ignore if property/method is abstract in parent class
+					if (parentCheck.isAbstract) {
+						continue;
+					}
+
+					// Ignore if property/method already exists (non-private) in parent class
+					// Because we cannot make a parent's public property private
+					if (parentCheck.existsInParent) {
+						continue;
+					}
+
+					if (!vueSourceFile.includes(`setup.${prop.name}`) && !prop.isPrivate) {
+						prop.inError = true;
+						const itemType = prop.type === 'MethodDefinition' ? 'Method' : 'Property';
+						context.report({
+							message: `Oops! ${itemType} "${prop.name}" should be private as not used in associated .vue file`,
+							loc: {
+								start: prop.member.loc.start,
+								end: prop.member.loc.end,
+							},
+							fix: (fixer) => {
+								// If member has decorators, insert "private" after last decorator
+								if (prop.member.decorators && prop.member.decorators.length > 0) {
+									const lastDecorator = prop.member.decorators[prop.member.decorators.length - 1];
+									return fixer.insertTextAfter(lastDecorator, ' private');
+								}
+								// Otherwise, insert "private" before the member
+								return fixer.insertTextBefore(prop.member, 'private ');
+							},
+						});
+					}
+				}
+			},
+		};
+	},
+};