add strict types for language names and display names

packages/quicktype-core/src/Run.ts

@@ -21,7 +21,9 @@ import { makeTransformations } from "./MakeTransformations";
 import { TransformedStringTypeKind } from "./Type";
 import { type Comment } from "./support/Comments";
 
-export function getTargetLanguage(nameOrInstance: string | TargetLanguage): TargetLanguage {
+import { type LanguageName } from "types";
+
+export function getTargetLanguage(nameOrInstance: LanguageName | TargetLanguage): TargetLanguage {
     if (typeof nameOrInstance === "object") {
         return nameOrInstance;
     }
@@ -123,7 +125,7 @@ export type NonInferenceOptions = {
      * or a string specifying one of the names for quicktype's built-in target languages.  For example,
      * both `cs` and `csharp` will generate C#.
      */
-    lang: string | TargetLanguage;
+    lang: LanguageName | TargetLanguage;
     /** The input data from which to produce types */
     inputData: InputData;
     /** Put class properties in alphabetical order, instead of in the order found in the JSON */

packages/quicktype-core/src/language/All.ts

@@ -1,5 +1,3 @@
-import { iterableFind } from "collection-utils";
-
 import { TargetLanguage } from "../TargetLanguage";
 
 import { CSharpTargetLanguage } from "./CSharp";
@@ -28,6 +26,8 @@ import { TypeScriptZodTargetLanguage } from "./TypeScriptZod";
 import { PhpTargetLanguage } from "./Php";
 import { TypeScriptEffectSchemaTargetLanguage } from "./TypeScriptEffectSchema";
 
+import { type LanguageNameMap, type LanguageName } from "../types";
+
 export const all = [
     new CSharpTargetLanguage(),
     new GoTargetLanguage(),
@@ -59,14 +59,14 @@ export const all = [
 
 all satisfies readonly TargetLanguage[];
 
-export function languageNamed(
-    name: string,
+export function languageNamed<Name extends LanguageName>(
+    name: Name,
     targetLanguages: readonly TargetLanguage[] = all
-): TargetLanguage | undefined {
-    const maybeTargetLanguage = iterableFind(
-        targetLanguages,
-        l => l.names.indexOf(name) >= 0 || l.displayName === name
-    );
-    if (maybeTargetLanguage !== undefined) return maybeTargetLanguage;
-    return iterableFind(targetLanguages, l => l.extension === name);
+): LanguageNameMap[Name] {
+    const foundLanguage = targetLanguages.find(language => language.names.includes(name));
+    if (!foundLanguage) {
+        throw new Error(`Unknown language name: ${name}`);
+    }
+
+    return foundLanguage as LanguageNameMap[Name];
 }

packages/quicktype-core/src/language/JavaScript.ts

@@ -67,7 +67,7 @@ export type JavaScriptTypeAnnotations = {
 
 export class JavaScriptTargetLanguage<
     DisplayName extends string = "JavaScript",
-    Names extends readonly string[] = ["javascript", "js", "jsx"],
+    Names extends readonly string[] = readonly ["javascript", "js", "jsx"],
     Extension extends string = "js"
 > extends TargetLanguage<DisplayName, Names, Extension> {
     constructor(

packages/quicktype-core/src/types.ts

@@ -0,0 +1,14 @@
+import { type TargetLanguage } from "TargetLanguage";
+import type { all } from "./language/All";
+
+type AllLanguages = (typeof all)[number];
+
+export type LanguageDisplayName<Language extends TargetLanguage = AllLanguages> = Language["displayName"];
+export type LanguageName<Language extends TargetLanguage = AllLanguages> = Language["names"][number];
+
+export type LanguageDisplayNameMap = {
+    [Language in AllLanguages as LanguageDisplayName<Language>]: Language;
+};
+export type LanguageNameMap = {
+    [Language in AllLanguages as LanguageName<Language>]: Language;
+};