@orion.ui/orion-linter 1.0.0

package/dist/rules/async-suffix.js

@@ -0,0 +1,121 @@
+export default {
+	type: 'suggestion',
+	meta: {
+		docs: {
+			description: `enforce async function naming ends with 'Async'`,
+			category: `Possible Errors`,
+			recommended: true,
+			url: '',
+		},
+	},
+
+	create: function (context) {
+		const MISSING_ASYNC = `Names should end with 'Async' for async functions. Rename '{{name}}' to '{{name}}Async'`;
+		const EXTRA_ASYNC = `Non async names should not end with 'Async'. Rename '{{name}}Async' to '{{name}}'`;
+
+		const endsWithAsync = name => name.endsWith('Async');
+
+		const isReturningPromise = (node) => {
+			return node.value?.body?.body?.[0]?.argument?.callee?.name === 'Promise';
+		};
+
+		/**
+     * Check a node is valid
+     * @param  {Object}  node       The root node that is being checked
+     * @param  {Object}  identifier The identifier of the root node
+     * @param  {Boolean} isAsync    Whether the node is marked as async
+     */
+		const check = (node, identifier, isAsync) => {
+			// Unknown case that we don't handle
+			if (!identifier || !identifier.name) {
+				return;
+			}
+
+			const nameEndsWithAsync = endsWithAsync(identifier.name);
+
+			if (isAsync && !nameEndsWithAsync) {
+				context.report({
+					node: identifier,
+					message: MISSING_ASYNC,
+					data: { name: identifier.name },
+				});
+			}
+
+			if (!isAsync && nameEndsWithAsync) {
+				const lastIndex = identifier.name.lastIndexOf('Async');
+				const noneAsyncName = identifier.name.substring(0, lastIndex);
+
+				context.report({
+					node: identifier,
+					message: EXTRA_ASYNC,
+					data: { name: noneAsyncName },
+				});
+			}
+		};
+
+		const VariableDeclarator = (node) => {
+			const init = node.init;
+			const identifier = node.id;
+
+			if (init && identifier) {
+				check(node, identifier, init.async);
+			}
+		};
+
+		const MethodDefinition = (node) => {
+			const identifier = node.key;
+			const functionExpression = node.value;
+
+			if (identifier && functionExpression) {
+				check(
+					node,
+					identifier,
+					functionExpression.async || isReturningPromise(node),
+				);
+			}
+		};
+
+		const FunctionDeclaration = (node) => {
+			const identifier = node.id;
+
+			if (identifier) {
+				check(node, identifier, node.async || isReturningPromise(node));
+			}
+		};
+
+		const AssignmentExpression = (node) => {
+			const identifier = node.left;
+			const functionExpression = node.right;
+			if (
+				identifier
+				&& functionExpression
+				&& functionExpression.async !== undefined
+			) {
+				check(node, identifier, functionExpression.async);
+			}
+		};
+
+		const Property = (node) => {
+			// Only care for Methods
+			const identifier = node.key;
+			const functionExpression = node.value;
+
+			// Ignore shorthand node definitions
+			if (node.shorthand) {
+				return;
+			}
+
+			if (identifier && functionExpression) {
+				check(node, identifier, functionExpression.async);
+			}
+		};
+
+		return {
+			VariableDeclarator,
+			FunctionDeclaration,
+			MethodDefinition,
+			Property,
+			AssignmentExpression,
+		};
+	},
+};

package/dist/rules/class-name-match-filename.js

@@ -0,0 +1,34 @@
+import { sep } from 'node:path';
+
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that entity name matches its file name` },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		return {
+			ClassDeclaration(node) {
+				const fileName = context.getPhysicalFilename().split(sep).reverse()[0].replace(/\.ts$/, '');
+				const fileShouldBeChecked = /(Entity|Service|Api([A-Z]+\w*)?)$/.test(fileName);
+
+				if (!fileShouldBeChecked) return;
+
+				const className = node.id.name;
+
+				if (fileName === className) return;
+
+				context.report({
+					node,
+					message: `Oops !
+The class name ${className} do not correspond with its file name ${fileName}.
+Either rename the file or the class`,
+					fix: (fixer) => {
+						return fixer.replaceTextRange(node.id.range, fileName);
+					},
+				});
+			},
+		};
+	},
+};

package/dist/rules/default-props-are-static-readonly.js

@@ -0,0 +1,48 @@
+function getClassProperties(classNode) {
+	return classNode.body.body.filter(x => x.type === 'PropertyDefinition');
+}
+
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that default props in Setup are static and readonly` },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		return {
+			ClassDeclaration(node) {
+				if (/^Base[A-Z]/.test(node.id.name)) return;
+
+				const propsDeclaration = getClassProperties(node).filter(propertyNode => propertyNode.key.name === 'defaultProps')[0];
+
+				if (!propsDeclaration) return;
+				if (propsDeclaration.static && propsDeclaration.readonly) return;
+
+				const messages = [];
+				const fixers = [];
+
+				if (!propsDeclaration.static) {
+					messages.push(`\`defaultProps\` declaration should be \`static\`.`);
+					fixers.push('static');
+				}
+
+				if (!propsDeclaration.readonly) {
+					messages.push(`\`defaultProps\` declaration should be \`readonly\`.`);
+					fixers.push('readonly');
+				}
+
+				context.report({
+					node: propsDeclaration,
+					message: `Oops !
+${messages.join('\n')}`,
+					fix: (fixer) => {
+						return propsDeclaration.readonly
+							? fixer.insertTextBefore(propsDeclaration, fixers.join(' ') + ' ')
+							: fixer.insertTextBeforeRange(propsDeclaration.key.range, fixers.join(' ') + ' ');
+					},
+				});
+			},
+		};
+	},
+};

package/dist/rules/events-are-in-camel-case.js

@@ -0,0 +1,140 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: 'Event name must be in camelCase' },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		return {
+			Program(node) {
+				const sourceCode = context.getSourceCode();
+
+				const isInCamelCase = (str) => {
+					if (str.includes(':')) {
+						const strParts = str.split(':');
+						return strParts.every(part => isInCamelCase(part));
+					}
+
+					// Allow full template variables
+					if (str.match(/^\$\{.*\}$/)) return true;
+
+					// Allow Setup
+					if (/^[A-Z][a-zA-Z0-9]*Setup(Service)?$/.test(str)) return true;
+
+					// Handle template variables within the string
+					if (str.match(/\$\{.*\}/)) {
+						// Split by template variables and check each part
+						const parts = str.split(/\$\{[^}]+\}/g).filter(p => p !== '');
+						if (parts.length === 0) return true;
+						// First part should start with lowercase, others can start with uppercase
+						return parts.every((part, index) => {
+							if (index === 0 && str.startsWith(part)) {
+								// First part at the beginning of string
+								return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(part);
+							}
+							else {
+								// Part after a template variable can start with uppercase
+								return /^[A-Z]?[a-z0-9]*([A-Z][a-z0-9]*)*$/.test(part);
+							}
+						});
+					}
+
+					return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str);
+				};
+
+				const kebabToCamelCaseStrict = (str) => {
+					if (str.includes(':')) {
+						const strParts = str.split(':');
+						return strParts
+							.map((part) => {
+								return isInCamelCase(part)
+									? part
+									: kebabToCamelCaseStrict(part);
+							})
+							.join(':');
+					}
+
+					// Handle template variables
+					const templateVarRegex = /\$\{[^}]+\}/g;
+					const parts = str.split(templateVarRegex);
+					const templateVars = str.match(templateVarRegex) || [];
+
+					if (templateVars.length === 0) {
+						// No template variables, simple conversion
+						return str
+							.toLowerCase()
+							.replace(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+					}
+
+					// Convert each part
+					const convertedParts = parts.map((part, index) => {
+						// Remove leading and trailing dashes
+						part = part.replace(/^-+/, '').replace(/-+$/, '');
+
+						if (!part) return '';
+
+						// Convert to camelCase
+						const camelCase = part.toLowerCase().replace(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+
+						// If this part comes after a template variable (index > 0 and previous part exists or is at position 0 in original string)
+						// then capitalize first letter
+						if (index > 0) {
+							return camelCase.charAt(0).toUpperCase() + camelCase.substring(1);
+						}
+
+						return camelCase;
+					});
+
+					// Reassemble with template variables
+					let result = '';
+					for (let i = 0; i < convertedParts.length; i++) {
+						result += convertedParts[i];
+						if (i < templateVars.length) {
+							result += templateVars[i];
+						}
+					}
+
+					return result;
+				};
+
+				const busEventsRegex = /(registerBusEvent|((Bus\.|useBusService\(\)\.)on|once|emit|off)|((modal|aside|notif)\??\.trigger))\(['`"](?<event>[^'`"]+)['`"]/gm;
+				const emitEventsRegex = /Emits\s*=\s*\{\s*\(\w+:\s*['`"](?<event>[^'`"]+)['`"]/gm;
+				const matches = Array.from(sourceCode.getText().matchAll(busEventsRegex));
+				matches.push(...Array.from(sourceCode.getText().matchAll(emitEventsRegex)));
+
+				if (!matches.length) return;
+
+				matches.forEach((match) => {
+					const event = match.groups?.event;
+					if (!event) return;
+
+					if (!isInCamelCase(event)) {
+						const index = match.index + match[0].indexOf(event);
+						const loc = context.getSourceCode().getLocFromIndex(index);
+
+						context.report({
+							message: `Oops! Event "${event}" should be in camelCase (":" allowed).`,
+							loc: {
+								start: loc,
+								end: {
+									line: loc.line,
+									column: loc.column + event.length,
+								},
+							},
+							fix: (fixer) => {
+								const start = match.index + match[0].indexOf(event);
+								const end = start + event.length;
+
+								return fixer.replaceTextRange(
+									[start, end],
+									kebabToCamelCaseStrict(event),
+								);
+							},
+						});
+					}
+				});
+			},
+		};
+	},
+};

package/dist/rules/force-dynamic-vue-imports-in-router.js

@@ -0,0 +1,80 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: 'Enforce dynamic imports for Vue components in Router files and disallow static imports.' },
+		fixable: 'code',
+	},
+	create(context) {
+		const ROUTER_FILE_REGEX = /router\/.*\.ts$/;
+
+		// Check if the current file is a router file
+		if (!ROUTER_FILE_REGEX.test(context.getFilename())) {
+			return {}; // Not a Router file, so don't apply this rule
+		}
+
+		const importedComponents = []; // Define importedComponents inside create function
+
+		return {
+			// Check Property for 'component' key in route objects
+			Property(node) {
+				if (node.key.type === 'Identifier' && node.key.name === 'component') {
+					const componentValue = node.value;
+					const sourceCode = context.getSourceCode();
+
+					const isCorrectDynamicImport = componentValue.type === 'ArrowFunctionExpression'
+						&& componentValue.body.type === 'ImportExpression';
+
+					if (isCorrectDynamicImport) {
+						return; // This is valid, do nothing.
+					}
+
+					// Attempt to extract the import path if it's a static import or a different dynamic import
+					let importPath = '';
+					if (componentValue.type === 'Identifier') {
+						const componentIsImported = importedComponents.find(comp => comp.name === componentValue.name && comp.source.endsWith('.vue'));
+						if (componentIsImported) {
+							importPath = componentIsImported.source;
+						}
+					}
+					else if (componentValue.type === 'ImportExpression') { // Direct ImportExpression as component value
+						importPath = componentValue.source.value;
+					}
+					else if (componentValue.type === 'CallExpression' && componentValue.callee.type === 'ImportExpression') { // This case is for `import(...)` directly, not wrapped in arrow function
+						importPath = componentValue.arguments[0].value;
+					}
+					else if (componentValue.type === 'MemberExpression' && componentValue.object.type === 'AwaitExpression' && componentValue.object.argument.type === 'ImportExpression') {
+						importPath = componentValue.object.argument.source.value;
+					}
+
+					// If it's not the correct dynamic import, report it.
+					context.report({
+						node: componentValue,
+						message: 'Vue components in router files must use dynamic imports in the format `() => import(\'path/to/Component.vue\')`.',
+						fix(fixer) {
+							if (importPath) {
+								return fixer.replaceText(componentValue, `() => import('${importPath}')`);
+							}
+							return null; // Cannot fix automatically if path is not found
+						},
+					});
+				}
+			},
+			ImportDeclaration(node) {
+				importedComponents.push(...node.specifiers.map(s => ({
+					name: s.local.name,
+					source: node.source.value,
+				})));
+
+				if (node.source.value.endsWith('.vue')) {
+					context.report({
+						node,
+						message: 'Static import of Vue components is not allowed in Router files. Use dynamic import instead.',
+						fix(fixer) {
+							return fixer.remove(node);
+						},
+					});
+				}
+			},
+		};
+	},
+};

package/dist/rules/force-dynamic-vue-imports-in-services.js

@@ -0,0 +1,160 @@
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: 'Enforce dynamic imports for Vue components in Service and Setup files and disallow static imports.' },
+		fixable: 'code',
+	},
+	create(context) {
+		const SERVICE_OR_SETUP_FILE_REGEX = /(Service|Setup)\.ts$/;
+
+		// Check if the current file is a Service.ts or Setup.ts file
+		if (!SERVICE_OR_SETUP_FILE_REGEX.test(context.getFilename())) {
+			return {}; // Not a Service or Setup file, so don't apply this rule
+		}
+
+		const importedComponents = [];
+		let hasDefineAsyncComponent = false;
+		let vueImportNode = null;
+
+		// Helper function to ensure defineAsyncComponent is imported
+		const ensureDefineAsyncComponentImport = (fixer) => {
+			const sourceCode = context.getSourceCode();
+
+			if (hasDefineAsyncComponent) {
+				return null; // Already imported
+			}
+
+			if (vueImportNode) {
+				// Add defineAsyncComponent to existing vue import
+				const importSpecifiers = vueImportNode.specifiers;
+				if (importSpecifiers.length > 0) {
+					const lastSpecifier = importSpecifiers[importSpecifiers.length - 1];
+					return fixer.insertTextAfter(lastSpecifier, ', defineAsyncComponent');
+				}
+			}
+
+			// Add new import for defineAsyncComponent from vue at the beginning
+			const firstNode = sourceCode.ast.body[0];
+			if (firstNode) {
+				return fixer.insertTextBefore(firstNode, 'import { defineAsyncComponent } from \'vue\';\n');
+			}
+
+			return null;
+		};
+
+		// Helper function to check and fix Nested property in useModal/useAside
+		const checkNestedProperty = (node, functionName) => {
+			const options = node.arguments[0];
+
+			if (options.type === 'ObjectExpression') {
+				const nestedProperty = options.properties.find(
+					prop => prop.type === 'Property' && prop.key.type === 'Identifier' && prop.key.name === 'Nested',
+				);
+
+				if (nestedProperty) {
+					const nestedValue = nestedProperty.value;
+
+					const componentIsImported = importedComponents.find(
+						comp => nestedValue.type === 'Identifier' && comp.name === nestedValue.name && comp.source.endsWith('.vue'),
+					);
+
+					// Check if it's already using defineAsyncComponent
+					const isDefineAsyncComponent = nestedValue.type === 'CallExpression'
+						&& nestedValue.callee.type === 'Identifier'
+						&& nestedValue.callee.name === 'defineAsyncComponent';
+
+					if (isDefineAsyncComponent) {
+						return; // Already correct, do nothing
+					}
+
+					// Check if it's using the old pattern: (await import('...')).default
+					const isOldDynamicImportPattern = nestedValue.type === 'MemberExpression'
+						&& nestedValue.property.type === 'Identifier'
+						&& nestedValue.property.name === 'default'
+						&& nestedValue.object.type === 'AwaitExpression'
+						&& nestedValue.object.argument.type === 'ImportExpression';
+
+					if (isOldDynamicImportPattern) {
+						const importPath = nestedValue.object.argument.source.value;
+						context.report({
+							node: nestedValue,
+							message: `The \`Nested\` property in \`${functionName}\` should use \`defineAsyncComponent(() => import('...'))\` instead of \`(await import('...')).default\`.`,
+							fix(fixer) {
+								const fixes = [
+									fixer.replaceText(nestedValue, `defineAsyncComponent(() => import('${importPath}'))`),
+								];
+
+								const importFix = ensureDefineAsyncComponentImport(fixer);
+								if (importFix) {
+									fixes.push(importFix);
+								}
+
+								return fixes;
+							},
+						});
+						return;
+					}
+
+					if (componentIsImported) {
+						// Component is statically imported, suggest dynamic import with defineAsyncComponent
+						context.report({
+							node: nestedValue,
+							message: `The \`Nested\` property in \`${functionName}\` must use \`defineAsyncComponent\` with dynamic import instead of a static import.`,
+							fix(fixer) {
+								const componentImportPath = componentIsImported.source;
+								const fixes = [
+									fixer.replaceText(nestedValue, `defineAsyncComponent(() => import('${componentImportPath}'))`),
+								];
+
+								const importFix = ensureDefineAsyncComponentImport(fixer);
+								if (importFix) {
+									fixes.push(importFix);
+								}
+
+								return fixes;
+							},
+						});
+					}
+				}
+			}
+		};
+
+		return {
+
+			// Check useModal and useAside calls
+			CallExpression(node) {
+				if (node.callee.type === 'Identifier' && (node.callee.name === 'useModal' || node.callee.name === 'useAside') && node.arguments.length > 0) {
+					checkNestedProperty(node, node.callee.name);
+				}
+			},
+
+			ImportDeclaration(node) {
+				// Track imported components
+				importedComponents.push(...node.specifiers.map(s => ({
+					name: s.local.name,
+					source: node.source.value,
+				})));
+
+				// Track vue imports to check for defineAsyncComponent
+				if (node.source.value === 'vue') {
+					vueImportNode = node;
+					hasDefineAsyncComponent = node.specifiers.some(
+						spec => spec.type === 'ImportSpecifier' && spec.imported.name === 'defineAsyncComponent',
+					);
+				}
+
+				// Report static imports of .vue files
+				if (node.source.value.endsWith('.vue')) {
+					context.report({
+						node,
+						message: 'Static import of Vue components is not allowed in Service files. Use \`defineAsyncComponent\` with dynamic import instead.',
+						fix(fixer) {
+							return fixer.remove(node);
+						},
+					});
+				}
+			},
+
+		};
+	},
+};