@orion.ui/orion-linter 1.0.0

package/dist/rules/state-are-private-readonly.js

@@ -0,0 +1,89 @@
+function getClassProperties(classNode) {
+	return classNode.body.body.filter(x => x.type === 'PropertyDefinition');
+}
+
+export default {
+	meta: {
+		type: 'problem',
+		docs: { description: `check that props in Setup are static and readonly` },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		const fileName = context.getPhysicalFilename().split('/').reverse()[0];
+		const sourceCode = context.sourceCode;
+
+		if (fileName === 'BaseEntity.ts') return {};
+
+		return {
+			ClassDeclaration(node) {
+				const stateDeclarations = getClassProperties(node).filter((propertyNode) => {
+					return !(propertyNode.key.name === 'selfState' && fileName.includes('Entity.ts')) && propertyNode.key.name.toLowerCase().includes('state');
+				});
+
+				stateDeclarations.forEach((stateDeclaration) => {
+					if (!stateDeclaration || !/@Reactive/.test(sourceCode.getText(stateDeclaration))) return;
+
+					stateDeclaration.private = stateDeclaration.accessibility === 'private';
+
+					if (stateDeclaration.private && stateDeclaration.readonly) return;
+
+					const messages = [];
+					const fixers = [];
+
+					if (!stateDeclaration.private && !node.abstract) {
+						messages.push(`\`state\` declaration should be \`private\`.`);
+						fixers.push('private');
+					}
+
+					if (!stateDeclaration.readonly) {
+						messages.push(`\`state\` declaration should be \`readonly\`.`);
+						fixers.push('readonly');
+					}
+
+					if (messages.length) {
+						context.report({
+							node: stateDeclaration,
+							message: `Oops !
+  ${messages.join('\n')}`,
+							fix: (fixer) => {
+								const text = sourceCode.getText(stateDeclaration);
+
+								// Regex to capture @Decorator + modifiers + property name + assignment
+								const decoratorPattern = /^(\s*@\w+\s+)((?:private\s+|readonly\s+)*)(\w+)(\s*=.*)$/s;
+								const match = text.match(decoratorPattern);
+
+								if (match) {
+									const [, decoratorPart, existingModifiers, propertyName, valueAssignment] = match;
+
+									// Analyze existing modifiers
+									const hasReadonly = /readonly\s+/.test(existingModifiers);
+									const hasPrivate = /private\s+/.test(existingModifiers);
+
+									// Reconstruct text with correct order
+									let allModifiers = '';
+									if (hasPrivate || fixers.includes('private')) {
+										allModifiers += 'private ';
+									}
+									if (hasReadonly || fixers.includes('readonly')) {
+										allModifiers += 'readonly ';
+									}
+
+									const newText = decoratorPart + allModifiers + propertyName + valueAssignment;
+
+									return fixer.replaceTextRange(stateDeclaration.range, newText);
+								}
+								else {
+									// Fallback: original behavior if no decorator
+									return stateDeclaration.readonly
+										? fixer.insertTextBefore(stateDeclaration, fixers.join(' ') + ' ')
+										: fixer.insertTextBeforeRange(stateDeclaration.key.range, fixers.join(' ') + ' ');
+								}
+							},
+						});
+					}
+				});
+			},
+		};
+	},
+};

package/dist/rules/template-refs-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 template refs declared in Setup are readonly` },
+		fixable: 'code',
+	},
+
+	create: function (context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			ClassDeclaration(node) {
+				function getRefsDeclarations(classNode) {
+					const templateRefsRegex = /ref<(Orion[^>]*|HTML\w*)>\(\)/;
+					return getClassProperties(classNode)
+						.filter(propertyNode => templateRefsRegex.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(`Template refs name should begin with '_'.`);
+					if (!propertyNode.readonly) messages.push(`Template refs 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/types.d.ts

@@ -0,0 +1,10 @@
+export type LocalRuleName = 'async-suffix' | 'no-api-in-entity' | 'no-api-in-setup' | 'no-entity-in-service' | 'no-export-type-in-ts' | 'template-refs-are-readonly' | 'default-props-are-static-readonly' | 'state-are-private-readonly' | 'class-name-match-filename' | 'popables-are-readonly' | 'force-dynamic-vue-imports-in-services' | 'force-dynamic-vue-imports-in-router' | 'get-set-one-liner' | 'get-set-adjacent' | 'events-are-in-camel-case';
+export type ESLintRuleLevel = 'off' | 'warn' | 'error';
+export type LocalRuleConfig = {
+    [K in LocalRuleName as `orion-rules/${K}`]?: ESLintRuleLevel;
+};
+export type RuleOverrideConfig = {
+    files?: string[];
+    rules?: LocalRuleConfig;
+};
+export declare const ORION_RULES: Record<LocalRuleName, string>;

package/dist/types.js

@@ -0,0 +1,17 @@
+export const ORION_RULES = {
+    'async-suffix': 'orion-rules/async-suffix',
+    'no-api-in-entity': 'orion-rules/no-api-in-entity',
+    'no-api-in-setup': 'orion-rules/no-api-in-setup',
+    'no-entity-in-service': 'orion-rules/no-entity-in-service',
+    'no-export-type-in-ts': 'orion-rules/no-export-type-in-ts',
+    'template-refs-are-readonly': 'orion-rules/template-refs-are-readonly',
+    'default-props-are-static-readonly': 'orion-rules/default-props-are-static-readonly',
+    'state-are-private-readonly': 'orion-rules/state-are-private-readonly',
+    'class-name-match-filename': 'orion-rules/class-name-match-filename',
+    'popables-are-readonly': 'orion-rules/popables-are-readonly',
+    'force-dynamic-vue-imports-in-services': 'orion-rules/force-dynamic-vue-imports-in-services',
+    'force-dynamic-vue-imports-in-router': 'orion-rules/force-dynamic-vue-imports-in-router',
+    'get-set-one-liner': 'orion-rules/get-set-one-liner',
+    'get-set-adjacent': 'orion-rules/get-set-adjacent',
+    'events-are-in-camel-case': 'orion-rules/events-are-in-camel-case',
+};

package/dist/utils.d.ts

@@ -0,0 +1,29 @@
+import { ESLintRuleLevel, LocalRuleName, RuleOverrideConfig } from './types.js';
+/**
+ * Creates a configuration to disable specific rules
+ * @param rules - List of rules to disable
+ * @returns ESLint configuration to disable rules
+ */
+export declare function disableRules(rules: LocalRuleName[]): RuleOverrideConfig;
+/**
+ * Creates a configuration to define the error level for specific rules
+ * @param rules - Object with rules and their level
+ * @returns ESLint configuration for rules
+ */
+export declare function configureRules(rules: Partial<Record<LocalRuleName, ESLintRuleLevel>>): RuleOverrideConfig;
+/**
+ * Creates a configuration for specific files
+ * @param files - File patterns
+ * @param rules - Rule configuration
+ * @returns ESLint configuration for specific files
+ */
+export declare function configureForFiles(files: string[], rules: Partial<Record<LocalRuleName, ESLintRuleLevel>>): RuleOverrideConfig;
+/**
+ * List of all available rules with their full names
+ */
+export declare const AVAILABLE_RULES: Record<LocalRuleName, string>;
+/**
+ * Creates a configuration to disable all Orion rules
+ * @returns ESLint configuration to disable all rules
+ */
+export declare function disableAllOrionRules(): RuleOverrideConfig;

package/dist/utils.js

@@ -0,0 +1,66 @@
+import { ORION_RULES } from './types.js';
+/**
+ * Creates a configuration to disable specific rules
+ * @param rules - List of rules to disable
+ * @returns ESLint configuration to disable rules
+ */
+export function disableRules(rules) {
+    const rulesConfig = {};
+    rules.forEach(rule => {
+        rulesConfig[`orion-rules/${rule}`] = 'off';
+    });
+    return {
+        rules: rulesConfig
+    };
+}
+/**
+ * Creates a configuration to define the error level for specific rules
+ * @param rules - Object with rules and their level
+ * @returns ESLint configuration for rules
+ */
+export function configureRules(rules) {
+    const rulesConfig = {};
+    Object.entries(rules).forEach(([rule, level]) => {
+        if (level) {
+            rulesConfig[`orion-rules/${rule}`] = level;
+        }
+    });
+    return {
+        rules: rulesConfig
+    };
+}
+/**
+ * Creates a configuration for specific files
+ * @param files - File patterns
+ * @param rules - Rule configuration
+ * @returns ESLint configuration for specific files
+ */
+export function configureForFiles(files, rules) {
+    const rulesConfig = {};
+    Object.entries(rules).forEach(([rule, level]) => {
+        if (level) {
+            rulesConfig[`orion-rules/${rule}`] = level;
+        }
+    });
+    return {
+        files,
+        rules: rulesConfig
+    };
+}
+/**
+ * List of all available rules with their full names
+ */
+export const AVAILABLE_RULES = ORION_RULES;
+/**
+ * Creates a configuration to disable all Orion rules
+ * @returns ESLint configuration to disable all rules
+ */
+export function disableAllOrionRules() {
+    const rulesConfig = {};
+    Object.values(ORION_RULES).forEach(rule => {
+        rulesConfig[rule] = 'off';
+    });
+    return {
+        rules: rulesConfig
+    };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+	"version": "1.0.0",
+	"name": "@orion.ui/orion-linter",
+	"description": "Linting based on Stylistic & Stylelint",
+	"type": "module",
+	"author": "Orion UI <dev@orion-ui.org>",
+	"license": "MIT",
+	"homepage": "https://github.com/orion-ui/orion-linter#readme",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/orion-ui/orion-linter.git"
+	},
+	"bugs": {
+		"url": "https://github.com/orion-ui/orion-linter/issues"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": "./dist/index.js",
+	"files": [
+		"dist/",
+		"README.md"
+	],
+	"scripts": {
+		"build": "rimraf dist && tsc && npm run copy-configs",
+		"copy-configs": "cpy src/configs/**/* dist/configs && cpy src/rules/**/* dist/rules",
+		"prepack": "npm run build",
+		"prepublishOnly": "npm run build && npm run test:package",
+		"test:package": "node -e \"import('./dist/index.js').then(async pkg => { const config = await pkg.getESLintConfig(); console.log('Package test passed:', typeof config === 'object'); });\"",
+		"test": "node tests/rules/*.test.js"
+	},
+	"keywords": [
+		"eslint",
+		"stylelint",
+		"linter",
+		"typescript",
+		"vue",
+		"css",
+		"less",
+		"frontend"
+	],
+	"engines": {
+		"node": ">=18.12.0"
+	},
+	"peerDependencies": {
+		"eslint": "^9.0.0",
+		"stylelint": "^16.0.0",
+		"typescript": "^5.0.0"
+	},
+	"dependencies": {
+		"@stylistic/eslint-plugin": "^5.2.0",
+		"@stylistic/stylelint-config": "^2.0.0",
+		"@typescript-eslint/eslint-plugin": "^8.37.0",
+		"@typescript-eslint/parser": "^8.37.0",
+		"eslint-plugin-vue": "^10.3.0",
+		"stylelint-config-clean-order": "^7.0.0",
+		"stylelint-config-recommended-vue": "^1.6.1",
+		"stylelint-config-standard-less": "^3.0.1"
+	},
+	"devDependencies": {
+		"@types/eslint": "^9.6.1",
+		"@types/node": "^20.0.0",
+		"cpy-cli": "^5.0.0",
+		"rimraf": "^6.0.1",
+		"typescript": "^5.8.3"
+	}
+}