Merge pull request #26 from RoopikLabs/develop

Final Architecture: Core (Project Mode) + Extension (Canvas Component Mode)

Author: HumbleBee14

.eslint-plugin-local/code-amd-node-module.ts

@@ -4,11 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import * as ESTree from 'estree';
+import type * as ESTree from 'estree';
+import { readFileSync } from 'fs';
 import { join } from 'path';
 
 
-export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
+export default new class ApiProviderNaming implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -22,7 +23,8 @@ export = new class ApiProviderNaming implements eslint.Rule.RuleModule {
 		const modules = new Set<string>();
 
 		try {
-			const { dependencies, optionalDependencies } = require(join(__dirname, '../package.json'));
+			const packageJson = JSON.parse(readFileSync(join(import.meta.dirname, '../package.json'), 'utf-8'));
+			const { dependencies, optionalDependencies } = packageJson;
 			const all = Object.keys(dependencies).concat(Object.keys(optionalDependencies));
 			for (const key of all) {
 				modules.add(key);

.eslint-plugin-local/code-declare-service-brand.ts

@@ -4,9 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import * as ESTree from 'estree';
+import type * as ESTree from 'estree';
 
-export = new class DeclareServiceBrand implements eslint.Rule.RuleModule {
+export default new class DeclareServiceBrand implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		fixable: 'code',

.eslint-plugin-local/code-ensure-no-disposables-leak-in-test.ts

@@ -4,9 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import { Node } from 'estree';
+import type * as estree from 'estree';
 
-export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
+export default new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		type: 'problem',
@@ -18,15 +18,15 @@ export = new class EnsureNoDisposablesAreLeakedInTestSuite implements eslint.Rul
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const config = <{ exclude: string[] }>context.options[0];
+		const config = context.options[0] as { exclude: string[] };
 
 		const needle = context.getFilename().replace(/\\/g, '/');
 		if (config.exclude.some((e) => needle.endsWith(e))) {
 			return {};
 		}
 
 		return {
-			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: Node) => {
+			[`Program > ExpressionStatement > CallExpression[callee.name='suite']`]: (node: estree.Node) => {
 				const src = context.getSourceCode().getText(node);
 				if (!src.includes('ensureNoDisposablesAreLeakedInTestSuite(')) {
 					context.report({

.eslint-plugin-local/code-import-patterns.ts

@@ -7,9 +7,9 @@ import * as eslint from 'eslint';
 import { TSESTree } from '@typescript-eslint/utils';
 import * as path from 'path';
 import minimatch from 'minimatch';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
-const REPO_ROOT = path.normalize(path.join(__dirname, '../'));
+const REPO_ROOT = path.normalize(path.join(import.meta.dirname, '../'));
 
 interface ConditionalPattern {
 	when?: 'hasBrowser' | 'hasNode' | 'hasElectron' | 'test';
@@ -31,15 +31,15 @@ interface LayerAllowRule {
 type RawOption = RawImportPatternsConfig | LayerAllowRule;
 
 function isLayerAllowRule(option: RawOption): option is LayerAllowRule {
-	return !!((<LayerAllowRule>option).when && (<LayerAllowRule>option).allow);
+	return !!((option as LayerAllowRule).when && (option as LayerAllowRule).allow);
 }
 
 interface ImportPatternsConfig {
 	target: string;
 	restrictions: string[];
 }
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -55,7 +55,7 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		const options = <RawOption[]>context.options;
+		const options = context.options as RawOption[];
 		const configs = this._processOptions(options);
 		const relativeFilename = getRelativeFilename(context);
 
@@ -217,7 +217,7 @@ export = new class implements eslint.Rule.RuleModule {
 					configs.push(testConfig);
 				}
 			} else {
-				configs.push({ target, restrictions: <string[]>restrictions.filter(r => typeof r === 'string') });
+				configs.push({ target, restrictions: restrictions.filter(r => typeof r === 'string') as string[] });
 			}
 		}
 		this._optionsCache.set(options, configs);

.eslint-plugin-local/code-layering.ts

@@ -5,14 +5,14 @@
 
 import * as eslint from 'eslint';
 import { join, dirname } from 'path';
-import { createImportRuleListener } from './utils';
+import { createImportRuleListener } from './utils.ts';
 
 type Config = {
 	allowed: Set<string>;
 	disallowed: Set<string>;
 };
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -38,8 +38,7 @@ export = new class implements eslint.Rule.RuleModule {
 
 		const fileDirname = dirname(context.getFilename());
 		const parts = fileDirname.split(/\\|\//);
-		const ruleArgs = <Record<string, string[]>>context.options[0];
-
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 		let config: Config | undefined;
 		for (let i = parts.length - 1; i >= 0; i--) {
 			if (ruleArgs[parts[i]]) {
@@ -91,4 +90,3 @@ export = new class implements eslint.Rule.RuleModule {
 		});
 	}
 };
-

.eslint-plugin-local/code-limited-top-functions.ts

@@ -6,9 +6,9 @@
 import * as eslint from 'eslint';
 import { dirname, relative } from 'path';
 import minimatch from 'minimatch';
-import * as ESTree from 'estree';
+import type * as ESTree from 'estree';
 
-export = new class implements eslint.Rule.RuleModule {
+export default new class implements eslint.Rule.RuleModule {
 
 	readonly meta: eslint.Rule.RuleMetaData = {
 		messages: {
@@ -29,11 +29,11 @@ export = new class implements eslint.Rule.RuleModule {
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
-		let fileRelativePath = relative(dirname(__dirname), context.getFilename());
+		let fileRelativePath = relative(dirname(import.meta.dirname), context.getFilename());
 		if (!fileRelativePath.endsWith('/')) {
 			fileRelativePath += '/';
 		}
-		const ruleArgs = <Record<string, string[]>>context.options[0];
+		const ruleArgs = context.options[0] as Record<string, string[]>;
 
 		const matchingKey = Object.keys(ruleArgs).find(key => fileRelativePath.startsWith(key) || minimatch(fileRelativePath, key));
 		if (!matchingKey) {

.eslint-plugin-local/code-must-use-result.ts

@@ -4,22 +4,22 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import * as ESTree from 'estree';
+import type * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
 const VALID_USES = new Set<TSESTree.AST_NODE_TYPES | undefined>([
 	TSESTree.AST_NODE_TYPES.AwaitExpression,
 	TSESTree.AST_NODE_TYPES.VariableDeclarator,
 ]);
 
-export = new class MustUseResults implements eslint.Rule.RuleModule {
+export default new class MustUseResults implements eslint.Rule.RuleModule {
 	readonly meta: eslint.Rule.RuleMetaData = {
 		schema: false
 	};
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 
-		const config = <{ message: string; functions: string[] }[]>context.options[0];
+		const config = context.options[0] as { message: string; functions: string[] }[];
 		const listener: eslint.Rule.RuleListener = {};
 
 		for (const { message, functions } of config) {

.eslint-plugin-local/code-must-use-super-dispose.ts

@@ -3,11 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as eslint from 'eslint';
-import * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
+import * as eslint from 'eslint';
+import type * as ESTree from 'estree';
 
-export = new class NoAsyncSuite implements eslint.Rule.RuleModule {
+export default new class NoAsyncSuite implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		function doesCallSuperDispose(node: TSESTree.MethodDefinition) {

.eslint-plugin-local/code-no-any-casts.ts

@@ -6,7 +6,7 @@
 import * as eslint from 'eslint';
 import { TSESTree } from '@typescript-eslint/utils';
 
-export = new class NoAnyCasts implements eslint.Rule.RuleModule {
+export default new class NoAnyCasts implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {

.eslint-plugin-local/code-no-dangerous-type-assertions.ts

@@ -4,10 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as eslint from 'eslint';
-import * as ESTree from 'estree';
+import type * as ESTree from 'estree';
 import { TSESTree } from '@typescript-eslint/utils';
 
-export = new class NoDangerousTypeAssertions implements eslint.Rule.RuleModule {
+export default new class NoDangerousTypeAssertions implements eslint.Rule.RuleModule {
 
 	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
 		return {