Applied env and node presets per existing configurations

src/cli/main.ts

@@ -24,6 +24,7 @@ import {
 import { converters } from "../rules/converters";
 import { convertRules } from "../rules/convertRules";
 import { mergers } from "../rules/mergers";
+import { findPackagesConfiguration } from "../input/findPackagesConfiguration";
 
 const convertRulesDependencies = {
     converters,
@@ -36,6 +37,7 @@ const findConfigurationDependencies = {
 
 const findOriginalConfigurationsDependencies: FindOriginalConfigurationsDependencies = {
     findESLintConfiguration: bind(findESLintConfiguration, findConfigurationDependencies),
+    findPackagesConfiguration: bind(findPackagesConfiguration, findConfigurationDependencies),
     findTypeScriptConfiguration: bind(findTypeScriptConfiguration, findConfigurationDependencies),
     findTSLintConfiguration: bind(findTSLintConfiguration, findConfigurationDependencies),
 };

src/conversion/conversionResults.stubs.ts

@@ -1,8 +1,8 @@
-import { ConfigConversionResults } from "../rules/convertRules";
+import { RuleConversionResults } from "../rules/convertRules";
 
 export const createEmptyConversionResults = (
-    overrides: Partial<ConfigConversionResults>,
-): ConfigConversionResults => ({
+    overrides: Partial<RuleConversionResults>,
+): RuleConversionResults => ({
     converted: new Map(),
     failed: [],
     missing: [],

src/conversion/convertConfig.test.ts

@@ -1,6 +1,6 @@
 import { ResultStatus, FailedResult, SucceededDataResult } from "../types";
 import { convertConfig, ConvertConfigDependencies } from "./convertConfig";
-import { OriginalConfigurationsData } from "../input/findOriginalConfigurations";
+import { OriginalConfigurations } from "../input/findOriginalConfigurations";
 
 const createStubDependencies = (
     overrides: Pick<ConvertConfigDependencies, "findOriginalConfigurations">,
@@ -12,12 +12,10 @@ const createStubDependencies = (
 });
 
 const createStubOriginalConfigurationsData = () => ({
-    eslint: {},
     tslint: {
         rules: [],
         ruleDirectories: [],
     },
-    typescript: {},
 });
 
 describe("convertConfig", () => {
@@ -41,7 +39,7 @@ describe("convertConfig", () => {
 
     it("returns a successful result when finding the original configurations succeeds", async () => {
         // Arrange
-        const findSuccess: SucceededDataResult<OriginalConfigurationsData> = {
+        const findSuccess: SucceededDataResult<OriginalConfigurations> = {
             data: createStubOriginalConfigurationsData(),
             status: ResultStatus.Succeeded,
         };

src/conversion/convertConfig.ts

@@ -21,15 +21,12 @@ export const convertConfig = async (
         return originalConfigurations;
     }
 
-    const configConversonResults = dependencies.convertRules(
+    const ruleConversionResults = dependencies.convertRules(
         originalConfigurations.data.tslint.rules,
     );
 
-    await dependencies.writeConversionResults(
-        configConversonResults,
-        originalConfigurations.data.tslint,
-    );
-    dependencies.reportConversionResults(configConversonResults);
+    await dependencies.writeConversionResults(ruleConversionResults, originalConfigurations.data);
+    dependencies.reportConversionResults(ruleConversionResults);
 
     return {
         status: ResultStatus.Succeeded,

src/creation/eslint/createEnv.test.ts

@@ -0,0 +1,188 @@
+import { createEnv } from "./createEnv";
+import { TypeScriptConfiguration } from "../../input/findTypeScriptConfiguration";
+
+const createTypeScriptCompilerOptions = (
+    overrides: Partial<TypeScriptConfiguration["compilerOptions"]> = {},
+) => ({
+    target: "es3",
+    ...overrides,
+});
+
+describe("createEnv", () => {
+    it("returns node, browser, and es6 as true if typescript is undefined", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = undefined;
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                browser: true,
+                es6: true,
+                node: true,
+            }),
+        );
+    });
+
+    it("returns browser as true if no typescript libs are provided", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {
+            compilerOptions: createTypeScriptCompilerOptions(),
+        };
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                browser: true,
+            }),
+        );
+    });
+
+    it("returns browser as false if typescript libs don't include dom", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {
+            compilerOptions: createTypeScriptCompilerOptions({
+                lib: ["esnext"],
+            }),
+        };
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).not.toContain({
+            browser: expect.any(Boolean),
+        });
+    });
+
+    it("returns browser as true if a typescript lib is dom", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {
+            compilerOptions: createTypeScriptCompilerOptions({
+                lib: ["dom"],
+            }),
+        };
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                browser: true,
+            }),
+        );
+    });
+
+    it("returns es6 as false if the typescript target is lower than es6", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {
+            compilerOptions: createTypeScriptCompilerOptions({
+                target: "es5",
+            }),
+        };
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).not.toEqual(
+            expect.objectContaining({
+                es6: expect.any(Boolean),
+            }),
+        );
+    });
+
+    it("returns es6 as true if the typescript target includes es6", () => {
+        // Arrange
+        const packages = undefined;
+        const typescript = {
+            compilerOptions: createTypeScriptCompilerOptions({
+                target: "es2015",
+            }),
+        };
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                es6: true,
+            }),
+        );
+    });
+
+    it("returns node as false if package dependencies and devDependencies don't include @types/node", () => {
+        // Arrange
+        const packages = {
+            dependencies: {},
+            devDependencies: {
+                "@types/other": "1.2.3",
+            },
+        };
+        const typescript = undefined;
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).not.toEqual(
+            expect.objectContaining({
+                node: expect.any(Boolean),
+            }),
+        );
+    });
+
+    it("returns node as true if package dependencies include @types/node", () => {
+        // Arrange
+        const packages = {
+            dependencies: {
+                "@types/node": "1.2.3",
+            },
+            devDependencies: {},
+        };
+        const typescript = undefined;
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                node: true,
+            }),
+        );
+    });
+
+    it("returns node as true if package devDependencies include @types/node", () => {
+        // Arrange
+        const packages = {
+            dependencies: {},
+            devDependencies: {
+                "@types/node": "1.2.3",
+            },
+        };
+        const typescript = undefined;
+
+        // Act
+        const env = createEnv({ packages, typescript });
+
+        // Assert
+        expect(env).toEqual(
+            expect.objectContaining({
+                node: true,
+            }),
+        );
+    });
+});

src/creation/eslint/createEnv.ts

@@ -0,0 +1,27 @@
+import { OriginalConfigurations } from "../../input/findOriginalConfigurations";
+
+export const createEnv = ({
+    packages,
+    typescript,
+}: Pick<OriginalConfigurations, "packages" | "typescript">) => {
+    const browser =
+        typescript === undefined ||
+        typescript.compilerOptions.lib === undefined ||
+        typescript.compilerOptions.lib.includes("dom");
+
+    const es6 =
+        typescript === undefined ||
+        !["es3", "es5"].includes(typescript.compilerOptions.target.toLowerCase());
+
+    const node =
+        packages === undefined ||
+        [...Object.keys(packages.dependencies), ...Object.keys(packages.devDependencies)].some(
+            dependency => dependency.toLowerCase() === "@types/node",
+        );
+
+    return {
+        ...(browser && { browser }),
+        ...(es6 && { es6 }),
+        ...(node && { node }),
+    };
+};

src/creation/formatConvertedRules.ts

@@ -1,10 +1,10 @@
 import { TSLintConfiguration } from "../input/findTSLintConfiguration";
-import { ConfigConversionResults } from "../rules/convertRules";
+import { RuleConversionResults } from "../rules/convertRules";
 import { ESLintRuleOptions } from "../rules/types";
 import { formatMissingRules } from "./formatMissingRules";
 
 export const formatConvertedRules = (
-    conversionResults: ConfigConversionResults,
+    conversionResults: RuleConversionResults,
     tslintConfiguration: TSLintConfiguration,
 ) => {
     const output: { [i: string]: string | any[] } = {};

src/creation/writeConversionResults.test.ts

@@ -1,9 +1,11 @@
 import { createEmptyConversionResults } from "../conversion/conversionResults.stubs";
 import { writeConversionResults } from "./writeConversionResults";
 
-const tslintConfiguration = {
-    ruleDirectories: [],
-    rules: {},
+const originalConfigurations = {
+    tslint: {
+        ruleDirectories: [],
+        rules: {},
+    },
 };
 
 describe("writeConversionResults", () => {
@@ -15,13 +17,18 @@ describe("writeConversionResults", () => {
         const fileSystem = { writeFile: jest.fn().mockReturnValue(Promise.resolve()) };
 
         // Act
-        await writeConversionResults({ fileSystem }, conversionResults, tslintConfiguration);
+        await writeConversionResults({ fileSystem }, conversionResults, originalConfigurations);
 
         // Assert
         expect(fileSystem.writeFile).toHaveBeenLastCalledWith(
             ".eslintrc.json",
             JSON.stringify(
                 {
+                    env: {
+                        browser: true,
+                        es6: true,
+                        node: true,
+                    },
                     parser: "@typescript-eslint/parser",
                     parserOptions: {
                         project: "tsconfig.json",
@@ -49,13 +56,18 @@ describe("writeConversionResults", () => {
         const fileSystem = { writeFile: jest.fn().mockReturnValue(Promise.resolve()) };
 
         // Act
-        await writeConversionResults({ fileSystem }, conversionResults, tslintConfiguration);
+        await writeConversionResults({ fileSystem }, conversionResults, originalConfigurations);
 
         // Assert
         expect(fileSystem.writeFile).toHaveBeenLastCalledWith(
             ".eslintrc.json",
             JSON.stringify(
                 {
+                    env: {
+                        browser: true,
+                        es6: true,
+                        node: true,
+                    },
                     parser: "@typescript-eslint/parser",
                     parserOptions: {
                         project: "tsconfig.json",

src/creation/writeConversionResults.ts

@@ -1,26 +1,28 @@
 import { FileSystem } from "../adapters/fileSystem";
-import { TSLintConfiguration } from "../input/findTSLintConfiguration";
-import { ConfigConversionResults } from "../rules/convertRules";
+import { RuleConversionResults } from "../rules/convertRules";
 import { formatConvertedRules } from "./formatConvertedRules";
+import { OriginalConfigurations } from "../input/findOriginalConfigurations";
+import { createEnv } from "./eslint/createEnv";
 
 export type WriteConversionResultsDependencies = {
     fileSystem: Pick<FileSystem, "writeFile">;
 };
 
 export const writeConversionResults = async (
     dependencies: WriteConversionResultsDependencies,
-    conversionResults: ConfigConversionResults,
-    tslintConfiguration: TSLintConfiguration,
+    ruleConversionResults: RuleConversionResults,
+    originalConfigurations: OriginalConfigurations,
 ) => {
     const output = {
+        env: createEnv(originalConfigurations),
         parser: "@typescript-eslint/parser",
         parserOptions: {
             project: "tsconfig.json",
         },
-        ...(conversionResults.missing.length && {
+        ...(ruleConversionResults.missing.length && {
             plugins: ["@typescript-eslint/tslint"],
         }),
-        rules: formatConvertedRules(conversionResults, tslintConfiguration),
+        rules: formatConvertedRules(ruleConversionResults, originalConfigurations.tslint),
     };
 
     await dependencies.fileSystem.writeFile(".eslintrc.json", JSON.stringify(output, undefined, 4));