Support Prettier's native overrides instead of fileExtOverrides

I forgot we need to stay compatible with better_rules_javascript's own
self-formatting with Prettier, and it doesn't like the `require` syntax
I was using. Therefore, we'll just support Prettier's native `overrides`
by resolving for each file, and accept that it will do extra disk reads.

Author: nevadaperry

.github/workflows/build.yml

@@ -18,8 +18,7 @@ jobs:
       - name: Configure bazel
         run: .github/configure-bazel
       - name: Test
-        run:
-          bazel test tools/bazel:bazelrc.diff tools/lint:format_test
+        run: bazel test tools/bazel:bazelrc.diff tools/lint:format_test
           tools/lint:lint_test
         # needs rules_file to work with generate directories tools/javascript:js_diff
   test:

prettier/format/src/index.ts

@@ -1,10 +1,10 @@
 import { workerMain } from "@better-rules-javascript/bazel-worker";
 import { ArgumentParser } from "argparse";
-import * as path from "node:path";
+import { dirname } from "node:path";
 import { pathToFileURL } from "node:url";
-import { Options } from "prettier";
+import { Options, resolveConfig } from "prettier";
 import { load, resolve } from "./import";
-import { readFile, writeFile } from "node:fs/promises";
+import { PrettierWorker } from "./worker";
 
 interface Args {
   config?: string;
@@ -15,16 +15,13 @@ workerMain(async (a) => {
   parser.add_argument("--config", { help: "Configuration path" });
   const args: Args = parser.parse_args(a);
 
-  const { resolveConfig } = await import("prettier");
-  const { PrettierWorker } = await import("./worker");
-
   const options: Options | undefined =
     args.config === undefined
       ? undefined
       : (await resolveConfig(args.config, { config: args.config })) ||
         undefined;
   if (options?.plugins) {
-    const contextUrl = pathToFileURL(path.dirname(args.config!));
+    const contextUrl = pathToFileURL(dirname(args.config!));
     options.plugins = await Promise.all(
       options.plugins.map(async (plugin) => {
         // in theory, should be able to just resolve the path, but for some reason
@@ -38,8 +35,7 @@ workerMain(async (a) => {
       }),
     );
   }
-  const fileExtOverrides = (await require(path.resolve(args.config))).fileExtOverrides;
-  const worker = new PrettierWorker(options, fileExtOverrides);
+  const worker = new PrettierWorker(args.config, options?.plugins);
 
   return async (a) => {
     try {

prettier/format/src/worker.ts

@@ -1,27 +1,31 @@
 import { ArgumentParser } from "argparse";
 import { readFile, writeFile } from "node:fs/promises";
-import { Options, format } from "prettier";
+import { resolve } from "node:path";
+import { Options, format, resolveConfig } from "prettier";
 
 export class PrettierWorker {
   constructor(
-    readonly options: Options | undefined,
-    readonly fileExtOverrides: { [fileExt: string]: object } | undefined,
+    readonly configPath: string | undefined,
+    readonly plugins: any[] | undefined,
   ) {}
 
   async run(a: string[]) {
     const parser = new ArgumentParser();
     parser.add_argument("input");
     parser.add_argument("output");
     const args = parser.parse_args(a);
+
+    const resolvedConfig = await resolveConfig(resolve(args.input), {
+      config: this.configPath,
+    });
+    const options: Options = {
+      ...resolvedConfig,
+      plugins: this.plugins,
+    };
+
     const input = await readFile(args.input, "utf8");
     const output = await format(input, {
-      ...this.options,
-      ...Object.assign(
-        {},
-        ...Object.entries(this.fileExtOverrides ?? {})
-          .filter(([fileExt, overrides]) => args.input.endsWith(fileExt))
-          .map(([fileExt, overrides]) => overrides)
-      ),
+      ...options,
       filepath: args.input,
     });
     await writeFile(args.output, output, "utf8");

util/starlark/src/index.ts

@@ -37,7 +37,7 @@ export class StarlarkFile {
   constructor(readonly statements: StarlarkStatement[]) {}
 }
 
-function printArray(value: StarlarkArray, indent: string | undefined): string {
+function printArray(value: StarlarkArray, indent?: string | undefined): string {
   let output = "";
   output += "[";
   output += indent === undefined ? " " : "\n";
@@ -56,15 +56,15 @@ function printArray(value: StarlarkArray, indent: string | undefined): string {
   return output;
 }
 
-function printDict(value: StarlarkDict, indent: string | undefined): string {
+function printDict(value: StarlarkDict, indent?: string | undefined): string {
   let output = "";
   output += "{";
   output += indent === undefined ? " " : "\n";
   for (const [k, v] of value.elements) {
     if (indent !== undefined) {
       output += indent + "    ";
     }
-    output += printValue(k, undefined);
+    output += printValue(k);
     output += ": ";
     output += printValue(v, indent === undefined ? indent : indent + "    ");
     output += ",";
@@ -85,7 +85,7 @@ function printString(value: StarlarkString): string {
   return JSON.stringify(value.value);
 }
 
-function printValue(value: StarlarkValue, indent: string | undefined): string {
+function printValue(value: StarlarkValue, indent?: string | undefined): string {
   if (value instanceof StarlarkArray) {
     return printArray(value, indent);
   }