WIP: JSON patching

Author: JoshuaKGoldberg

src/converters/editorConfigs/converters/convertVSCodeConfig.ts

@@ -1,5 +1,5 @@
-import { merge } from "lodash";
 import * as path from "path";
+import * as ts from "typescript";
 
 import { parseJson } from "../../../utils";
 import { EditorConfigConverter } from "../types";
@@ -12,8 +12,19 @@ const knownMissingSettings = [
     "tslint.suppressWhileTypeErrorsPresent",
 ];
 
+const getJsonRoot = (sourceFile: ts.SourceFile) => {
+    const [rootStatement] = sourceFile.statements;
+
+    return ts.isExpressionStatement(rootStatement) && ts.isObjectLiteralExpression(rootStatement.expression)
+        ? rootStatement.expression
+        : undefined;
+}
+
+
 export const convertVSCodeConfig: EditorConfigConverter = (rawEditorSettings, settings) => {
     const editorSettings: Record<string, string | number | symbol> = parseJson(rawEditorSettings);
+    const missing = knownMissingSettings.filter((setting) => editorSettings[setting]);
+
     const autoFixOnSave =
         editorSettings["editor.codeActionsOnSave"] &&
         typeof editorSettings["editor.codeActionsOnSave"] === "object" &&
@@ -28,26 +39,97 @@ export const convertVSCodeConfig: EditorConfigConverter = (rawEditorSettings, se
             path.dirname(settings.config),
         );
 
-    const contents = JSON.stringify(
-        merge(
-            {},
-            editorSettings,
-            autoFixOnSave !== undefined && {
-                "editor.codeActionsOnSave": {
-                    "eslint.autoFixOnSave": autoFixOnSave,
-                },
-            },
-            eslintPathMatches && {
-                "eslint.options": {
-                    configFile: settings.config,
-                },
-            },
-        ),
-        null,
-        4,
-    );
+    // We can bail without making changes if there are no changes we need to make...
+    if (!autoFixOnSave && !eslintPathMatches) {
+        return { contents: rawEditorSettings, missing };
+    }
 
-    const missing = knownMissingSettings.filter((setting) => editorSettings[setting]);
+    // ...or the JSON file doesn't seem to be a normal {} object root
+    const sourceFile = ts.createSourceFile("settings.json", rawEditorSettings, ts.ScriptTarget.Latest, /*setParentNodes*/ true, ts.ScriptKind.JSON);
+    const jsonRoot = getJsonRoot(sourceFile);
+    if (!jsonRoot) {
+        return { contents: rawEditorSettings, missing };
+    }
+
+    const propertyIndexByName = (properties: ts.NodeArray<ts.ObjectLiteralElementLike>, name: string) =>
+        properties.findIndex(property => property.name && ts.isStringLiteral(property.name) && property.name.text === name);
+
+    const transformer = (context: ts.TransformationContext) => (rootNode: ts.SourceFile): ts.SourceFile => {
+        const upsertProperties = (node: ts.ObjectLiteralExpression, additions: readonly [string, string, unknown][]) => {
+            const originalProperties = node.properties;
+
+            for (const [parent, setting, value] of additions) {
+                const createNewChild = (properties?: ts.NodeArray<ts.ObjectLiteralElementLike>) => {
+                    return context.factory.createPropertyAssignment(
+                        `"${parent}"`,
+                        context.factory.createObjectLiteralExpression(
+                            [
+                                ...properties ?? [],
+                                context.factory.createPropertyAssignment(
+                                    `"${setting}"`,
+                                    typeof value === "string"
+                                        ? context.factory.createStringLiteral(value)
+                                        : value
+                                            ? context.factory.createTrue()
+                                            : context.factory.createFalse()
+                                )
+                            ],
+                            true
+                        ),
+                    );
+                }
+
+                const existingIndex = propertyIndexByName(originalProperties, parent);
+
+                if (existingIndex !== -1) {
+                    const existingProperty = originalProperties[existingIndex];
+                    if (
+                        !ts.isPropertyAssignment(existingProperty)
+                        || !ts.isObjectLiteralExpression(existingProperty.initializer)
+                        || propertyIndexByName(existingProperty.initializer.properties, `"${parent}"`) === -1) {
+                        return node;
+                    }
+
+                    const updatedProperties = [...node.properties];
+                    updatedProperties[existingIndex] = createNewChild(existingProperty.initializer.properties)
+                    node = context.factory.createObjectLiteralExpression(updatedProperties, true);
+                } else {
+                    node = context.factory.createObjectLiteralExpression([...node.properties, createNewChild()], true);
+                }
+            }
+
+            return node;
+        };
+
+        const visit = (node: ts.Node) => {
+            node = ts.visitEachChild(node, visit, context);
+
+            if (node !== jsonRoot) {
+                return node;
+            }
+
+            const additions: [string, string, unknown][] = [];
+
+            if (autoFixOnSave !== undefined) {
+                additions.push(["editor.codeActionsOnSave", "eslint.autoFixOnSave", autoFixOnSave]);
+            }
+
+            if (eslintPathMatches !== undefined) {
+                additions.push(["eslint.options", "configFile", settings.config]);
+            }
+
+            return upsertProperties(jsonRoot, additions);
+        };
+
+        return ts.visitNode(rootNode, visit)
+    };
+
+    const printer = ts.createPrinter(undefined);
+    const result = ts.transform(sourceFile, [transformer]);
+    const contents = printer.printFile(result.transformed[0])
+        .replace(/^\(/giu, "")
+        .replace(/\);(\r\n|\r|\n)*$/giu, "$1")
+    result.dispose();
 
     return { contents, missing };
 };