Adopt Biome lint rules

biome.json

@@ -18,10 +18,114 @@
         "indentWidth": 4
     },
     "linter": {
-        "enabled": false
+        "enabled": true,
+        "rules": {
+            "preset": "recommended",
+            "correctness": {
+                "noUndeclaredDependencies": "on",
+                "noGlobalDirnameFilename": "on",
+                "noUnusedInstantiation": "on",
+                "useSingleJsDocAsterisk": "on",
+                "noConstructorReturn": "off",
+                "noVoidTypeReturn": "off"
+            },
+            "complexity": {
+                "noUselessReturn": "on",
+                "noDivRegex": "on",
+                "noUselessCatchBinding": "on",
+                "noUselessStringConcat": "on",
+                "useArrayFind": "on",
+                "useWhile": "on",
+                "noRedundantDefaultExport": "on",
+                "noExcessiveNestedTestSuites": "on"
+            },
+            "performance": {
+                "noDelete": "on"
+            },
+            "style": {
+                "noUselessElse": "off",
+                "useCollapsedElseIf": "on",
+                "useCollapsedIf": "on",
+                "useThrowNewError": "on",
+                "useConsistentBuiltinInstantiation": "on",
+                "useObjectSpread": "on",
+                "noYodaExpression": "on",
+                "noSubstr": "on",
+                "useExplicitLengthCheck": "on",
+                "noMultiAssign": "on",
+                "useConsistentObjectDefinitions": "on",
+                "useForOf": "on",
+                "noUnusedTemplateLiteral": "on",
+                "useShorthandAssign": "on",
+                "noInferrableTypes": "on",
+                "useDefaultParameterLast": "on",
+                "useConsistentMethodSignatures": "on",
+                "useUnifiedTypeSignatures": "on",
+                "noNamespace": "on",
+                "useNodeAssertStrict": "on",
+                "useReadonlyClassProperties": "on",
+                "useThrowOnlyError": "on",
+                "useTrimStartEnd": "on",
+                "useSymbolDescription": "on",
+                "useSpreadOverApply": "on",
+                "useNumberNamespace": "on",
+                "useGlobalThis": "on",
+                "useErrorCause": "on"
+            },
+            "suspicious": {
+                "noTemplateCurlyInString": "off",
+                "noEqualsToNull": "on",
+                "noUnusedExpressions": "on",
+                "useArraySortCompare": "on",
+                "noMisplacedAssertion": "on",
+                "noShadow": "on",
+                "noConstantBinaryExpressions": "on",
+                "noVar": "on",
+                "noFocusedTests": "on",
+                "noSkippedTests": "on",
+                "noReturnAssign": "on",
+                "noDuplicateTestHooks": "on",
+                "noDeprecatedImports": "on",
+                "noDuplicateDependencies": "on",
+                "useErrorMessage": "on",
+                "noEmptySource": "on"
+            }
+        }
     },
     "assist": { "actions": { "source": { "organizeImports": "off" } } },
     "overrides": [
+        {
+            "includes": [
+                "packages/quicktype-core/src/language/CJSON/CJSONRenderer.ts"
+            ],
+            "linter": {
+                "rules": {
+                    "suspicious": {
+                        "noShadow": "off"
+                    }
+                }
+            }
+        },
+        {
+            "includes": ["test/release-version.ts"],
+            "linter": {
+                "rules": {
+                    "suspicious": {
+                        "noMisplacedAssertion": "off"
+                    }
+                }
+            }
+        },
+        {
+            "includes": ["packages/quicktype-core/src/**"],
+            "linter": {
+                "rules": {
+                    "style": {
+                        "useNodejsImportProtocol": "off"
+                    }
+                }
+            }
+        },
         {
             "includes": ["**/tsconfig.json", "**/tsconfig.*.json"],
             "json": {

package.json

@@ -45,7 +45,8 @@
         "quicktype-typescript-input": "24.0.0",
         "readable-stream": "^4.5.2",
         "stream-json": "1.8.0",
-        "string-to-stream": "^3.0.1"
+        "string-to-stream": "^3.0.1",
+        "wordwrap": "^1.0.0"
     },
     "devDependencies": {
         "@biomejs/biome": "^2.5.3",

packages/quicktype-core/src/ConvenienceRenderer.ts

@@ -39,7 +39,6 @@ import {
 import {
     type BlankLineConfig,
     type ForEachPosition,
-    type RenderContext,
     Renderer,
 } from "./Renderer.js";
 import {
@@ -54,7 +53,6 @@ import {
 } from "./support/Comments.js";
 import { trimEnd } from "./support/Strings.js";
 import { assert, defined, nonNull, panic } from "./support/Support.js";
-import type { TargetLanguage } from "./TargetLanguage.js";
 import {
     type Transformation,
     followTargetType,
@@ -177,13 +175,6 @@ export abstract class ConvenienceRenderer extends Renderer {
 
     private _alphabetizeProperties = false;
 
-    public constructor(
-        targetLanguage: TargetLanguage,
-        renderContext: RenderContext,
-    ) {
-        super(targetLanguage, renderContext);
-    }
-
     public get topLevels(): ReadonlyMap<string, Type> {
         return this.typeGraph.topLevels;
     }
@@ -834,9 +825,9 @@ export abstract class ConvenienceRenderer extends Renderer {
                 (_doubleType) => "double",
                 (_stringType) => "string",
                 (arrayType) =>
-                    typeNameForUnionMember(arrayType.items) + "_array",
+                    `${typeNameForUnionMember(arrayType.items)}_array`,
                 (classType) => lookup(this.nameForNamedType(classType)),
-                (mapType) => typeNameForUnionMember(mapType.values) + "_map",
+                (mapType) => `${typeNameForUnionMember(mapType.values)}_map`,
                 (objectType) => {
                     assert(
                         this.targetLanguage.supportsFullObjectType,
@@ -1275,7 +1266,7 @@ export abstract class ConvenienceRenderer extends Renderer {
         // A quote at the end of the line would merge with a closing
         // `"""` emitted right after it.  The quote needs escaping iff
         // it's preceded by an even number of backslashes.
-        if (lineEnd !== undefined && lineEnd.startsWith('"')) {
+        if (lineEnd?.startsWith('"')) {
             const trailing = /(\\*)"$/.exec(escaped);
             if (trailing !== null && trailing[1].length % 2 === 0) {
                 escaped = `${escaped.slice(0, -1)}\\"`;

packages/quicktype-core/src/CycleBreaker.ts

@@ -107,8 +107,6 @@ export function breakCycles<T>(
             results.push([breakNode, info]);
             break;
         }
-
-        continue;
     }
 
     return results;

packages/quicktype-core/src/DeclarationIR.ts

@@ -195,8 +195,6 @@ export function declarationsForGraph(
             for (const t of forwardDeclarable) {
                 declarations.push({ kind: "define", type: t });
             }
-
-            return;
         }
 
         /*

packages/quicktype-core/src/MakeTransformations.ts

@@ -175,7 +175,7 @@ function replaceUnion(
         );
     }
 
-    let maybeStringType: TypeRef | undefined = undefined;
+    let maybeStringType: TypeRef | undefined;
     function getStringType(): TypeRef {
         if (maybeStringType === undefined) {
             maybeStringType = builder.getStringType(

packages/quicktype-core/src/MarkovChain.ts

@@ -69,7 +69,8 @@ function increment(t: Trie, seq: string, i: number): void {
 
     let st = t.arr[first];
     if (st === null) {
-        t.arr[first] = st = makeTrie();
+        st = makeTrie();
+        t.arr[first] = st;
     }
 
     if (typeof st !== "object") {
@@ -116,10 +117,10 @@ export function evaluateFull(
         }
 
         scores.push(cp);
-        p = p * cp;
+        p *= cp;
     }
 
-    return [Math.pow(p, 1 / (word.length - depth + 1)), scores];
+    return [p ** (1 / (word.length - depth + 1)), scores];
 }
 
 export function evaluate(mc: MarkovChain, word: string): number {

packages/quicktype-core/src/Messages.ts

@@ -14,7 +14,10 @@ export type ErrorProperties =
           kind: "MiscReadError";
           properties: { fileOrURL: string; message: string };
       }
-    | { kind: "MiscUnicodeHighSurrogateWithoutLowSurrogate"; properties: {} }
+    | {
+          kind: "MiscUnicodeHighSurrogateWithoutLowSurrogate";
+          properties: Record<string, never>;
+      }
     | {
           kind: "MiscInvalidMinMaxConstraint";
           properties: { max: number; min: number };
@@ -55,23 +58,23 @@ export type ErrorProperties =
       }
     | {
           kind: "SchemaRequiredMustBeStringOrStringArray";
-          properties: { actual: any; ref: Ref };
+          properties: { actual: unknown; ref: Ref };
       }
     | {
           kind: "SchemaRequiredElementMustBeString";
-          properties: { element: any; ref: Ref };
+          properties: { element: unknown; ref: Ref };
       }
     | {
           kind: "SchemaTypeMustBeStringOrStringArray";
-          properties: { actual: any };
+          properties: { actual: unknown };
       }
     | {
           kind: "SchemaTypeElementMustBeString";
-          properties: { element: any; ref: Ref };
+          properties: { element: unknown; ref: Ref };
       }
     | {
           kind: "SchemaArrayItemsMustBeStringOrArray";
-          properties: { actual: any; ref: Ref };
+          properties: { actual: unknown; ref: Ref };
       }
     | { kind: "SchemaIDMustHaveAddress"; properties: { id: string; ref: Ref } }
     | {
@@ -80,7 +83,7 @@ export type ErrorProperties =
       }
     | {
           kind: "SchemaSetOperationCasesIsNotArray";
-          properties: { cases: any; operation: string; ref: Ref };
+          properties: { cases: unknown; operation: string; ref: Ref };
       }
     | {
           kind: "SchemaMoreThanOneUnionMemberName";
@@ -98,38 +101,44 @@ export type ErrorProperties =
     | { kind: "SchemaFetchErrorAdditional"; properties: { address: string } }
 
     // GraphQL input
-    | { kind: "GraphQLNoQueriesDefined"; properties: {} }
+    | { kind: "GraphQLNoQueriesDefined"; properties: Record<string, never> }
 
     // Driver
     | { kind: "DriverUnknownSourceLanguage"; properties: { lang: string } }
     | { kind: "DriverUnknownOutputLanguage"; properties: { lang: string } }
     | { kind: "DriverMoreThanOneInputGiven"; properties: { topLevel: string } }
     | { kind: "DriverCannotInferNameForSchema"; properties: { uri: string } }
-    | { kind: "DriverNoGraphQLQueryGiven"; properties: {} }
+    | { kind: "DriverNoGraphQLQueryGiven"; properties: Record<string, never> }
     | { kind: "DriverNoGraphQLSchemaInDir"; properties: { dir: string } }
     | {
           kind: "DriverMoreThanOneGraphQLSchemaInDir";
           properties: { dir: string };
       }
-    | { kind: "DriverSourceLangMustBeGraphQL"; properties: {} }
-    | { kind: "DriverGraphQLSchemaNeeded"; properties: {} }
+    | {
+          kind: "DriverSourceLangMustBeGraphQL";
+          properties: Record<string, never>;
+      }
+    | { kind: "DriverGraphQLSchemaNeeded"; properties: Record<string, never> }
     | { kind: "DriverInputFileDoesNotExist"; properties: { filename: string } }
     | {
           kind: "DriverCannotMixJSONWithOtherSamples";
           properties: { dir: string };
       }
     | { kind: "DriverCannotMixNonJSONInputs"; properties: { dir: string } }
     | { kind: "DriverUnknownDebugOption"; properties: { option: string } }
-    | { kind: "DriverNoLanguageOrExtension"; properties: {} }
+    | { kind: "DriverNoLanguageOrExtension"; properties: Record<string, never> }
     | { kind: "DriverCLIOptionParsingFailed"; properties: { message: string } }
 
     // IR
-    | { kind: "IRNoForwardDeclarableTypeInCycle"; properties: {} }
+    | {
+          kind: "IRNoForwardDeclarableTypeInCycle";
+          properties: Record<string, never>;
+      }
     | {
           kind: "IRTypeAttributesNotPropagated";
           properties: { count: number; indexes: number[] };
       }
-    | { kind: "IRNoEmptyUnions"; properties: {} }
+    | { kind: "IRNoEmptyUnions"; properties: Record<string, never> }
 
     // Rendering
     | {
@@ -288,7 +297,7 @@ export function messageError<Kind extends ErrorKinds>(
             valueString = value;
         }
 
-        userMessage = userMessage.replace("${" + name + "}", valueString);
+        userMessage = userMessage.replace(`\${${name}}`, valueString);
     }
 
     throw new QuickTypeError(

packages/quicktype-core/src/Renderer.ts

@@ -51,7 +51,7 @@ function lineIndentation(line: string): {
         } else if (c === "\t") {
             indent = (indent / 4 + 1) * 4;
         } else {
-            return { indent, text: line.substring(i) };
+            return { indent, text: line.slice(i) };
         }
     }
 
@@ -77,7 +77,8 @@ class EmitContext {
     private _preventBlankLine: boolean;
 
     public constructor() {
-        this._currentEmitTarget = this._emitted = [];
+        this._emitted = [];
+        this._currentEmitTarget = this._emitted;
         this._numBlankLinesNeeded = 0;
         this._preventBlankLine = true; // no blank lines at start of file
     }

packages/quicktype-core/src/RendererOptions/index.ts

@@ -87,14 +87,16 @@ export class BooleanOption<Name extends string> extends Option<Name, boolean> {
         actual: Array<OptionDefinition<Name, boolean>>;
         display: Array<OptionDefinition<Name, boolean>>;
     } {
-        const negated = Object.assign({}, this.definition, {
+        const negated = {
+            ...this.definition,
             name: `no-${this.name}`,
             defaultValue: !this.definition.defaultValue,
-        });
-        const display = Object.assign({}, this.definition, {
+        } as OptionDefinition<Name, boolean>;
+        const display = {
+            ...this.definition,
             name: `[no-]${this.name}`,
             description: `${this.definition.description} (${this.definition.defaultValue ? "on" : "off"} by default)`,
-        });
+        } as OptionDefinition<Name, boolean>;
         return {
             display: [display],
             actual: [this.definition, negated],