@tsslint/config 0.0.0

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/findConfigFile';
+export * from './lib/tslint';
+export * from './lib/types';
+import type { Config } from './lib/types';
+export declare function defineConfig(config: Config): Config;
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+__exportStar(require("./lib/findConfigFile"), exports);
+__exportStar(require("./lib/tslint"), exports);
+__exportStar(require("./lib/types"), exports);
+function defineConfig(config) {
+    return config;
+}
+exports.defineConfig = defineConfig;
+//# sourceMappingURL=index.js.map

package/lib/findConfigFile.d.ts

@@ -0,0 +1,2 @@
+export declare function findConfigFile(dir: string): string | undefined;
+//# sourceMappingURL=findConfigFile.d.ts.map

package/lib/findConfigFile.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigFile = void 0;
+const path = require("path");
+function findConfigFile(dir) {
+    const dirs = [dir];
+    let upDir;
+    while ((upDir = path.resolve(dir, '..')) !== dirs[dirs.length - 1]) {
+        dirs.push(upDir);
+        dir = upDir;
+    }
+    for (const dir of dirs) {
+        try {
+            return require.resolve('./tsslint.config.ts', { paths: [dir] });
+        }
+        catch { }
+    }
+}
+exports.findConfigFile = findConfigFile;
+//# sourceMappingURL=findConfigFile.js.map

package/lib/loadConfig.d.ts

@@ -0,0 +1,20 @@
+import type { Config } from './types';
+import esbuild = require('/Users/johnsonchu/Desktop/GitHub/tsslint/node_modules/.pnpm/esbuild@0.19.9/node_modules/esbuild/lib/main.js');
+export interface LoadConfigResult {
+    config: Config | undefined;
+    errors: esbuild.Message[];
+    warnings: esbuild.Message[];
+}
+export declare function findConfigFile(dir: string): string | undefined;
+export declare function watchConfig(tsConfigPath: string, onBuild: (result: LoadConfigResult) => void): Promise<esbuild.BuildContext<{
+    entryPoints: string[];
+    bundle: true;
+    outfile: string;
+    format: "cjs";
+    platform: "node";
+    plugins: {
+        name: string;
+        setup(build: esbuild.PluginBuild): void;
+    }[];
+}>>;
+//# sourceMappingURL=loadConfig.d.ts.map

package/lib/loadConfig.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchConfig = exports.findConfigFile = void 0;
+const path = require("path");
+const esbuild = require("/Users/johnsonchu/Desktop/GitHub/tsslint/node_modules/.pnpm/esbuild@0.19.9/node_modules/esbuild/lib/main.js");
+function findConfigFile(dir) {
+    const dirs = [dir];
+    let upDir;
+    while ((upDir = path.resolve(dir, '..')) !== dirs[dirs.length - 1]) {
+        dirs.push(upDir);
+        dir = upDir;
+    }
+    for (const dir of dirs) {
+        try {
+            return require.resolve('./tsslint.config.ts', { paths: [dir] });
+        }
+        catch { }
+    }
+}
+exports.findConfigFile = findConfigFile;
+async function watchConfig(tsConfigPath, onBuild) {
+    const jsConfigPath = tsConfigPath.slice(0, -'.ts'.length) + '.cjs';
+    const ctx = await esbuild.context({
+        entryPoints: [tsConfigPath],
+        bundle: true,
+        outfile: jsConfigPath,
+        format: 'cjs',
+        platform: 'node',
+        plugins: [{
+                name: 'tsslint',
+                setup(build) {
+                    build.onEnd(result => {
+                        let config;
+                        if (!result.errors.length) {
+                            delete require.cache[jsConfigPath];
+                            try {
+                                config = require(jsConfigPath).default;
+                            }
+                            catch (e) {
+                                result.errors.push({ text: String(e) });
+                            }
+                        }
+                        onBuild({
+                            config: config,
+                            errors: result.errors,
+                            warnings: result.warnings,
+                        });
+                    });
+                },
+            }],
+    });
+    await ctx.watch();
+    return ctx;
+}
+exports.watchConfig = watchConfig;
+//# sourceMappingURL=loadConfig.js.map

package/lib/tslint.d.ts

@@ -0,0 +1,5 @@
+import * as TSLint from 'tslint';
+import type { Rule } from './types';
+export declare function parseTSLintRules(rules: TSLint.IRule[]): Record<string, Rule>;
+export declare function parseTSLintRule(rule: TSLint.IRule): Rule;
+//# sourceMappingURL=tslint.d.ts.map

package/lib/tslint.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTSLintRule = exports.parseTSLintRules = void 0;
+function parseTSLintRules(rules) {
+    const result = {};
+    for (const rule of rules) {
+        const { ruleName } = rule.getOptions();
+        result[ruleName] = parseTSLintRule(rule);
+    }
+    return result;
+}
+exports.parseTSLintRules = parseTSLintRules;
+function parseTSLintRule(rule) {
+    return ({ sourceFile, reportError, reportWarning }) => {
+        const { ruleSeverity } = rule.getOptions();
+        if (ruleSeverity === 'off') {
+            return;
+        }
+        const failures = rule.apply(sourceFile);
+        for (const failure of failures) {
+            failure.setRuleSeverity(ruleSeverity);
+            const report = failure.getRuleSeverity() === 'error' ? reportError : reportWarning;
+            for (let i = 0; i < failures.length; i++) {
+                const failure = failures[i];
+                const reporter = report(failure.getFailure(), failure.getStartPosition().getPosition(), failure.getEndPosition().getPosition());
+                if (failure.hasFix()) {
+                    const fix = failure.getFix();
+                    const replaces = Array.isArray(fix) ? fix : [fix];
+                    for (const replace of replaces) {
+                        if (replace) {
+                            reporter.withFix('Replace with ' + replace.text, () => [{
+                                    fileName: sourceFile.fileName,
+                                    textChanges: [{
+                                            newText: replace.text,
+                                            span: {
+                                                start: replace.start,
+                                                length: replace.length,
+                                            },
+                                        }],
+                                }]);
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+exports.parseTSLintRule = parseTSLintRule;
+//# sourceMappingURL=tslint.js.map

package/lib/types.d.ts

@@ -0,0 +1,44 @@
+import type { FileTextChanges, LanguageService, LanguageServiceHost, SourceFile, Diagnostic, ApplicableRefactorInfo, TextRange } from 'typescript/lib/tsserverlibrary';
+import type * as esbuild from 'esbuild';
+export interface ProjectContext {
+    configFile: string;
+    typescript: typeof import('typescript/lib/tsserverlibrary.js');
+    languageServiceHost: LanguageServiceHost;
+    languageService: LanguageService;
+    tsconfig?: string;
+}
+export interface Config {
+    rules?: Rules;
+    plugins?: Plugin[];
+}
+export interface Plugin {
+    (projectContext: ProjectContext, configBuildResult: esbuild.BuildResult): PluginInstance | Promise<PluginInstance>;
+}
+export interface PluginInstance {
+    lint?(sourceFile: SourceFile, rules: Rules): Diagnostic[];
+    getFixes?(sourceFile: SourceFile, positionOrRange: number | TextRange): ApplicableRefactorInfo[];
+    fix?(sourceFile: SourceFile, refactorName: string, actionName: string): FileTextChanges[] | undefined;
+    resolveRules?(rules: Rules): Rules;
+    resolveResult?(results: Diagnostic[]): Diagnostic[];
+}
+export interface Rules {
+    [name: string]: Rule;
+}
+export interface Rule {
+    (context: RuleContext): void;
+}
+export interface RuleContext {
+    typescript: typeof import('typescript/lib/tsserverlibrary.js');
+    languageServiceHost: LanguageServiceHost;
+    languageService: LanguageService;
+    sourceFile: SourceFile;
+    reportError(message: string, start: number, end: number): Reporter;
+    reportWarning(message: string, start: number, end: number): Reporter;
+    reportSuggestion(message: string, start: number, end: number): Reporter;
+}
+export interface Reporter {
+    withDeprecated(): Reporter;
+    withUnnecessary(): Reporter;
+    withFix(title: string, getChanges: () => FileTextChanges[]): Reporter;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "@tsslint/config",
+	"version": "0.0.0",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/tsslint.git",
+		"directory": "packages/config"
+	},
+	"peerDependencies": {
+		"tslint": "*"
+	},
+	"peerDependenciesMeta": {
+		"tslint": {
+			"optional": true
+		}
+	}
+}