expand-my-type 0.7.0 → 0.8.0

package/README.md

@@ -18,8 +18,7 @@ expanded form as a string. That can be useful for code-generation, testing, and
 debugging complex type errors.
 
 Under the hood, it uses the [TypeScript Compiler API][ts-compiler-api] to expand
-the type expression and optionally formats the output using
-[Prettier][prettier].
+the type expression and optionally formats the output using Biome.
 
 ## CLI
 
@@ -137,6 +136,30 @@ the following ways:
    /* { a: string; b: number } */
    ```
 
+Advanced users can pass Biome configuration directly:
+
+```typescript
+import { expandMyType } from "expand-my-type";
+
+const expandedType = await expandMyType({
+  typeExpression: "SomeType",
+  sourceFileName: "./example.ts",
+  prettify: {
+    biomeOptions: {
+      formatter: {
+        indentStyle: "space",
+        lineWidth: 120,
+      },
+      javascript: {
+        formatter: {
+          semicolons: "always",
+        },
+      },
+    },
+  },
+});
+```
+
 For local development in this repository, use Bun:
 
 ```sh
@@ -178,5 +201,4 @@ This approach comes with some limitations. Most notably, expanding a type that
 leads to an infinite recursion might throw an error (when prettify option is
 enabled), return a truncated output, or return any.
 
-[prettier]: https://prettier.io
 [ts-compiler-api]: https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API

package/dist/augmenter-compiler-host.d.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 type ExtractFunctions<T, K extends keyof T = keyof T> = {
-    [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;
+    [P in K]: Extract<T[P], (...args: never[]) => unknown>;
 };
 export type CompilerHostFunctionOverrides = Partial<ExtractFunctions<ts.CompilerHost>>;
 /**

package/dist/cli.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 
+// src/index.ts
+import path from "node:path";
+import ts2 from "typescript";
+
 // src/augmenter-compiler-host.ts
 import ts from "typescript";
 var createAugmenterCompilerHost = (sourceFileName, codeToAdd, compilerOptions, compilerHostFunctionOverrides) => {
@@ -27,8 +31,23 @@ ${contents}`;
 };
 
 // src/code-generator.ts
-import { format } from "prettier";
+import { Biome } from "@biomejs/js-api/nodejs";
 var identifierPrefix = "__EXPAND_MY_TYPE__";
+var virtualFormatFileName = "expand-my-type.ts";
+var biome = new Biome;
+var { projectKey } = biome.openProject();
+var defaultBiomeConfiguration = {
+  formatter: {
+    enabled: true,
+    indentStyle: "space"
+  },
+  javascript: {
+    formatter: {
+      quoteStyle: "double",
+      semicolons: "asNeeded"
+    }
+  }
+};
 var createExpandCodeBlock = (typeExpression) => {
   return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
     type ${identifierPrefix}Expression = ${typeExpression};
@@ -45,18 +64,40 @@ var createExpandCodeBlock = (typeExpression) => {
     type ${identifierPrefix}AppendUnderscore<T extends string> = \`\${T}_\` extends string ? \`\${T}_\` : never;
     type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \`\${infer U}_\` ? U : never;`;
 };
-var formatTypeExpression = async (code, prettierOptions) => {
-  return (await format(`type ${identifierPrefix} = ${code}`, prettierOptions ?? {
-    parser: "typescript",
-    semi: false
-  })).trim().substring(`type ${identifierPrefix} = `.length);
+var formatTypeExpression = async (code, biomeConfiguration) => {
+  const input = `type ${identifierPrefix} = ${code}`;
+  const javascriptFormatter = {
+    ...defaultBiomeConfiguration.javascript?.formatter,
+    ...biomeConfiguration?.javascript?.formatter
+  };
+  biome.applyConfiguration(projectKey, {
+    ...defaultBiomeConfiguration,
+    ...biomeConfiguration,
+    formatter: {
+      ...defaultBiomeConfiguration.formatter,
+      ...biomeConfiguration?.formatter
+    },
+    javascript: {
+      ...defaultBiomeConfiguration.javascript,
+      ...biomeConfiguration?.javascript,
+      formatter: javascriptFormatter
+    }
+  });
+  const result = biome.formatContent(projectKey, input, {
+    filePath: virtualFormatFileName
+  });
+  if (result.diagnostics.length > 0) {
+    throw new Error(biome.printDiagnostics(result.diagnostics, {
+      filePath: virtualFormatFileName,
+      fileSource: input
+    }));
+  }
+  return result.content.trim().substring(`type ${identifierPrefix} = `.length);
 };
 
 // src/index.ts
-import path from "node:path";
-import ts2 from "typescript";
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!ts2.isIdentifier(node)) {
       return;
     }
@@ -109,10 +150,10 @@ async function expandMyType(options) {
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, ts2.TypeFormatFlags.NodeBuilderFlagsMask);
-  if (options.prettify && options.prettify.enabled === false) {
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
 
 // src/cli.ts
@@ -186,16 +227,17 @@ var usagePrompt = [
   "  -c, --tsconfig <file>\t\tUse the specified tsconfig.json file"
 ].join(`
 `);
-if (positionals.length !== 2) {
-  console.error(usagePrompt);
-  process.exit(1);
-}
 if (values.help) {
   console.error(usagePrompt);
   process.exit(0);
 }
+if (positionals.length !== 2) {
+  console.error(usagePrompt);
+  process.exit(1);
+}
 var [sourceFileName, typeExpression] = positionals;
-var { prettify, tsconfig: tsConfigFileName } = values;
+var prettify = values.prettify ?? true;
+var tsConfigFileName = values.tsconfig;
 var tsParsedCommandLine;
 if (tsConfigFileName) {
   const configFile = ts3.readConfigFile(tsConfigFileName, ts3.sys.readFile);
@@ -212,5 +254,5 @@ var result = await expandMyType({
 });
 console.log(result);
 
-//# debugId=CDA842588C4AEC4564756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/augmenter-compiler-host.ts", "../src/code-generator.ts", "../src/index.ts", "../src/cli.ts"],
  "sourcesContent": [
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import type { Options as PrettierOptions } from \"prettier\";\nimport { format } from \"prettier\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  prettierOptions?: PrettierOptions,\n) => {\n  return (\n    await format(\n      `type ${identifierPrefix} = ${code}`,\n      prettierOptions ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${identifierPrefix} = `.length);\n};\n",
    "import { createAugmenterCompilerHost } from \"./augmenter-compiler-host.js\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\nimport path from \"node:path\";\nimport type { Options as PrettierOptions } from \"prettier\";\nimport ts from \"typescript\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() == 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettier options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Prettier options. Don't forget to set the parser to \"typescript\".\n     * @default { parser: \"typescript\", semi: false }\n     */\n    options?: PrettierOptions;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(expandedTypeString, options.prettify?.options);\n}\n",
    "#!/usr/bin/env node\nimport { expandMyType } from \"./index.js\";\nimport { parseArgs, type ParseArgsConfig } from \"node:util\";\nimport ts from \"typescript\";\n\ntype Values = {\n  help?: boolean;\n  prettify: boolean;\n  tsconfig?: string;\n};\n\nconst tryParse = <\n  Values extends Record<\n    string,\n    string | boolean | Array<string | boolean> | undefined\n  >,\n  Options extends ParseArgsConfig[\"options\"] = ParseArgsConfig[\"options\"],\n>(\n  options: Options,\n): { error?: Error; values: Values; positionals: string[] } => {\n  let result: ReturnType<typeof parseArgs>;\n  try {\n    result = parseArgs({\n      options,\n      tokens: true,\n      allowPositionals: true,\n    });\n  } catch (error) {\n    return {\n      error: error instanceof Error ? error : new Error(String(error)),\n      values: {} as Values,\n      positionals: [],\n    };\n  }\n\n  const { tokens, values, positionals } = result;\n\n  // Reprocess the option tokens and overwrite the returned values.\n  for (const token of tokens ?? []) {\n    if (token.kind === \"option-terminator\" || token.kind === \"positional\") {\n      continue;\n    }\n\n    if (token.name.startsWith(\"no-\")) {\n      // Store foo:false for --no-foo\n      const positiveName = token.name.slice(\"no-\".length);\n      values[positiveName] = false;\n      delete values[token.name];\n    } else {\n      // Resave value so last one wins if both --foo and --no-foo.\n      values[token.name] = token.value ?? true;\n    }\n  }\n\n  return {\n    error: undefined,\n    values: values as Values,\n    positionals,\n  };\n};\n\nconst { error, values, positionals } = tryParse<Values>({\n  help: {\n    type: \"boolean\",\n    short: \"h\",\n  },\n  prettify: {\n    type: \"boolean\",\n    short: \"p\",\n    default: true,\n  },\n  \"no-prettify\": {\n    type: \"boolean\",\n    short: \"P\",\n  },\n  tsconfig: {\n    type: \"string\",\n    short: \"c\",\n  },\n});\n\nif (error) {\n  console.error(error.message);\n  process.exit(1);\n}\n\nconst usagePrompt = [\n  \"Usage:\",\n  \"  expand-my-type [options] <source-file> <expression>\",\n  \"\",\n  \"Options:\",\n  \"  -h, --help\\t\\t\\tShow this help message\",\n  \"  -p, --prettify\\t\\tPrettify the output (default)\",\n  \"  -P, --no-prettify\\t\\tDo not prettify the output\",\n  \"  -c, --tsconfig <file>\\t\\tUse the specified tsconfig.json file\",\n].join(\"\\n\");\n\nif (positionals.length !== 2) {\n  console.error(usagePrompt);\n  process.exit(1);\n}\n\nif (values.help) {\n  console.error(usagePrompt);\n  process.exit(0);\n}\n\nconst [sourceFileName, typeExpression] = positionals;\nconst { prettify, tsconfig: tsConfigFileName } = values;\n\nlet tsParsedCommandLine: ts.ParsedCommandLine | undefined;\n\nif (tsConfigFileName) {\n  const configFile = ts.readConfigFile(tsConfigFileName, ts.sys.readFile);\n  const compilerOptions = ts.parseJsonConfigFileContent(\n    configFile.config,\n    ts.sys,\n    \"./\",\n  );\n\n  tsParsedCommandLine = compilerOptions;\n}\n\nconst result = await expandMyType({\n  sourceFileName,\n  typeExpression,\n  prettify: {\n    enabled: prettify,\n  },\n  tsCompilerOptions: tsParsedCommandLine?.options,\n});\n\nconsole.log(result);\n"
  ],
  "mappings": "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",
  "debugId": "CDA842588C4AEC4564756E2164756E21",
  "names": []
}
+//# debugId=D978D5D6AFCBBE8D64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/augmenter-compiler-host.ts", "../src/code-generator.ts", "../src/cli.ts"],
  "sourcesContent": [
    "import path from \"node:path\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\nimport ts from \"typescript\";\nimport {\n  type CompilerHostFunctionOverrides,\n  createAugmenterCompilerHost,\n} from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() === 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettify options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Biome formatting configuration.\n     */\n    biomeOptions?: BiomeConfiguration;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify?.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(\n    expandedTypeString,\n    options.prettify?.biomeOptions,\n  );\n}\n",
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: Extract<T[P], (...args: never[]) => unknown>;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import { Biome } from \"@biomejs/js-api/nodejs\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\nconst virtualFormatFileName = \"expand-my-type.ts\";\nconst biome = new Biome();\nconst { projectKey } = biome.openProject();\n\nconst defaultBiomeConfiguration: BiomeConfiguration = {\n  formatter: {\n    enabled: true,\n    indentStyle: \"space\",\n  },\n  javascript: {\n    formatter: {\n      quoteStyle: \"double\",\n      semicolons: \"asNeeded\",\n    },\n  },\n};\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  biomeConfiguration?: BiomeConfiguration,\n) => {\n  const input = `type ${identifierPrefix} = ${code}`;\n  const javascriptFormatter = {\n    ...defaultBiomeConfiguration.javascript?.formatter,\n    ...biomeConfiguration?.javascript?.formatter,\n  };\n\n  biome.applyConfiguration(projectKey, {\n    ...defaultBiomeConfiguration,\n    ...biomeConfiguration,\n    formatter: {\n      ...defaultBiomeConfiguration.formatter,\n      ...biomeConfiguration?.formatter,\n    },\n    javascript: {\n      ...defaultBiomeConfiguration.javascript,\n      ...biomeConfiguration?.javascript,\n      formatter: javascriptFormatter,\n    },\n  });\n\n  const result = biome.formatContent(projectKey, input, {\n    filePath: virtualFormatFileName,\n  });\n\n  if (result.diagnostics.length > 0) {\n    throw new Error(\n      biome.printDiagnostics(result.diagnostics, {\n        filePath: virtualFormatFileName,\n        fileSource: input,\n      }),\n    );\n  }\n\n  return result.content.trim().substring(`type ${identifierPrefix} = `.length);\n};\n",
    "#!/usr/bin/env node\nimport { type ParseArgsConfig, parseArgs } from \"node:util\";\nimport ts from \"typescript\";\nimport { expandMyType } from \"./index.js\";\n\ntype Values = {\n  help?: boolean;\n  prettify?: boolean;\n  \"no-prettify\"?: boolean;\n  tsconfig?: string;\n};\n\nconst tryParse = <\n  Values extends Record<\n    string,\n    string | boolean | Array<string | boolean> | undefined\n  >,\n  Options extends ParseArgsConfig[\"options\"] = ParseArgsConfig[\"options\"],\n>(\n  options: Options,\n): { error?: Error; values: Values; positionals: string[] } => {\n  let result: ReturnType<typeof parseArgs>;\n  try {\n    result = parseArgs({\n      options,\n      tokens: true,\n      allowPositionals: true,\n    });\n  } catch (error) {\n    return {\n      error: error instanceof Error ? error : new Error(String(error)),\n      values: {} as Values,\n      positionals: [],\n    };\n  }\n\n  const { tokens, values, positionals } = result;\n\n  // Reprocess the option tokens and overwrite the returned values.\n  for (const token of tokens ?? []) {\n    if (token.kind === \"option-terminator\" || token.kind === \"positional\") {\n      continue;\n    }\n\n    if (token.name.startsWith(\"no-\")) {\n      // Store foo:false for --no-foo\n      const positiveName = token.name.slice(\"no-\".length);\n      values[positiveName] = false;\n      delete values[token.name];\n    } else {\n      // Resave value so last one wins if both --foo and --no-foo.\n      values[token.name] = token.value ?? true;\n    }\n  }\n\n  return {\n    error: undefined,\n    values: values as Values,\n    positionals,\n  };\n};\n\nconst { error, values, positionals } = tryParse<Values>({\n  help: {\n    type: \"boolean\",\n    short: \"h\",\n  },\n  prettify: {\n    type: \"boolean\",\n    short: \"p\",\n    default: true,\n  },\n  \"no-prettify\": {\n    type: \"boolean\",\n    short: \"P\",\n  },\n  tsconfig: {\n    type: \"string\",\n    short: \"c\",\n  },\n});\n\nif (error) {\n  console.error(error.message);\n  process.exit(1);\n}\n\nconst usagePrompt = [\n  \"Usage:\",\n  \"  expand-my-type [options] <source-file> <expression>\",\n  \"\",\n  \"Options:\",\n  \"  -h, --help\\t\\t\\tShow this help message\",\n  \"  -p, --prettify\\t\\tPrettify the output (default)\",\n  \"  -P, --no-prettify\\t\\tDo not prettify the output\",\n  \"  -c, --tsconfig <file>\\t\\tUse the specified tsconfig.json file\",\n].join(\"\\n\");\n\nif (values.help) {\n  console.error(usagePrompt);\n  process.exit(0);\n}\n\nif (positionals.length !== 2) {\n  console.error(usagePrompt);\n  process.exit(1);\n}\n\nconst [sourceFileName, typeExpression] = positionals;\nconst prettify = values.prettify ?? true;\nconst tsConfigFileName = values.tsconfig;\n\nlet tsParsedCommandLine: ts.ParsedCommandLine | undefined;\n\nif (tsConfigFileName) {\n  const configFile = ts.readConfigFile(tsConfigFileName, ts.sys.readFile);\n  const compilerOptions = ts.parseJsonConfigFileContent(\n    configFile.config,\n    ts.sys,\n    \"./\",\n  );\n\n  tsParsedCommandLine = compilerOptions;\n}\n\nconst result = await expandMyType({\n  sourceFileName,\n  typeExpression,\n  prettify: {\n    enabled: prettify,\n  },\n  tsCompilerOptions: tsParsedCommandLine?.options,\n});\n\nconsole.log(result);\n"
  ],
  "mappings": "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",
  "debugId": "D978D5D6AFCBBE8D64756E2164756E21",
  "names": []
}

package/dist/code-generator.d.ts

@@ -1,3 +1,3 @@
-import type { Options as PrettierOptions } from "prettier";
+import type { Configuration as BiomeConfiguration } from "@biomejs/wasm-nodejs";
 export declare const createExpandCodeBlock: (typeExpression: string) => string;
-export declare const formatTypeExpression: (code: string, prettierOptions?: PrettierOptions) => Promise<string>;
+export declare const formatTypeExpression: (code: string, biomeConfiguration?: BiomeConfiguration) => Promise<string>;

package/dist/index.cjs

@@ -66,6 +66,8 @@ __export(exports_src, {
   expandMyType: () => expandMyType
 });
 module.exports = __toCommonJS(exports_src);
+var import_node_path = __toESM(require("node:path"));
+var import_typescript2 = __toESM(require("typescript"));
 
 // src/augmenter-compiler-host.ts
 var import_typescript = __toESM(require("typescript"));
@@ -94,8 +96,23 @@ ${contents}`;
 };
 
 // src/code-generator.ts
-var import_prettier = require("prettier");
+var import_nodejs = require("@biomejs/js-api/nodejs");
 var identifierPrefix = "__EXPAND_MY_TYPE__";
+var virtualFormatFileName = "expand-my-type.ts";
+var biome = new import_nodejs.Biome;
+var { projectKey } = biome.openProject();
+var defaultBiomeConfiguration = {
+  formatter: {
+    enabled: true,
+    indentStyle: "space"
+  },
+  javascript: {
+    formatter: {
+      quoteStyle: "double",
+      semicolons: "asNeeded"
+    }
+  }
+};
 var createExpandCodeBlock = (typeExpression) => {
   return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
     type ${identifierPrefix}Expression = ${typeExpression};
@@ -112,18 +129,40 @@ var createExpandCodeBlock = (typeExpression) => {
     type ${identifierPrefix}AppendUnderscore<T extends string> = \`\${T}_\` extends string ? \`\${T}_\` : never;
     type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \`\${infer U}_\` ? U : never;`;
 };
-var formatTypeExpression = async (code, prettierOptions) => {
-  return (await import_prettier.format(`type ${identifierPrefix} = ${code}`, prettierOptions ?? {
-    parser: "typescript",
-    semi: false
-  })).trim().substring(`type ${identifierPrefix} = `.length);
+var formatTypeExpression = async (code, biomeConfiguration) => {
+  const input = `type ${identifierPrefix} = ${code}`;
+  const javascriptFormatter = {
+    ...defaultBiomeConfiguration.javascript?.formatter,
+    ...biomeConfiguration?.javascript?.formatter
+  };
+  biome.applyConfiguration(projectKey, {
+    ...defaultBiomeConfiguration,
+    ...biomeConfiguration,
+    formatter: {
+      ...defaultBiomeConfiguration.formatter,
+      ...biomeConfiguration?.formatter
+    },
+    javascript: {
+      ...defaultBiomeConfiguration.javascript,
+      ...biomeConfiguration?.javascript,
+      formatter: javascriptFormatter
+    }
+  });
+  const result = biome.formatContent(projectKey, input, {
+    filePath: virtualFormatFileName
+  });
+  if (result.diagnostics.length > 0) {
+    throw new Error(biome.printDiagnostics(result.diagnostics, {
+      filePath: virtualFormatFileName,
+      fileSource: input
+    }));
+  }
+  return result.content.trim().substring(`type ${identifierPrefix} = `.length);
 };
 
 // src/index.ts
-var import_node_path = __toESM(require("node:path"));
-var import_typescript2 = __toESM(require("typescript"));
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!import_typescript2.default.isIdentifier(node)) {
       return;
     }
@@ -176,11 +215,11 @@ async function expandMyType(options) {
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, import_typescript2.default.TypeFormatFlags.NodeBuilderFlagsMask);
-  if (options.prettify && options.prettify.enabled === false) {
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
 
-//# debugId=FD61D95A1BB3AC7F64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/augmenter-compiler-host.ts", "src/code-generator.ts", "src/index.ts"],
  "sourcesContent": [
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import type { Options as PrettierOptions } from \"prettier\";\nimport { format } from \"prettier\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  prettierOptions?: PrettierOptions,\n) => {\n  return (\n    await format(\n      `type ${identifierPrefix} = ${code}`,\n      prettierOptions ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${identifierPrefix} = `.length);\n};\n",
    "import { createAugmenterCompilerHost } from \"./augmenter-compiler-host.js\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\nimport path from \"node:path\";\nimport type { Options as PrettierOptions } from \"prettier\";\nimport ts from \"typescript\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() == 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettier options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Prettier options. Don't forget to set the parser to \"typescript\".\n     * @default { parser: \"typescript\", semi: false }\n     */\n    options?: PrettierOptions;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(expandedTypeString, options.prettify?.options);\n}\n"
  ],
  "mappings": "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",
  "debugId": "FD61D95A1BB3AC7F64756E2164756E21",
  "names": []
}
+//# debugId=914AF96172681B5164756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/index.ts", "src/augmenter-compiler-host.ts", "src/code-generator.ts"],
  "sourcesContent": [
    "import path from \"node:path\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\nimport ts from \"typescript\";\nimport {\n  type CompilerHostFunctionOverrides,\n  createAugmenterCompilerHost,\n} from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() === 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettify options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Biome formatting configuration.\n     */\n    biomeOptions?: BiomeConfiguration;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify?.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(\n    expandedTypeString,\n    options.prettify?.biomeOptions,\n  );\n}\n",
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: Extract<T[P], (...args: never[]) => unknown>;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import { Biome } from \"@biomejs/js-api/nodejs\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\nconst virtualFormatFileName = \"expand-my-type.ts\";\nconst biome = new Biome();\nconst { projectKey } = biome.openProject();\n\nconst defaultBiomeConfiguration: BiomeConfiguration = {\n  formatter: {\n    enabled: true,\n    indentStyle: \"space\",\n  },\n  javascript: {\n    formatter: {\n      quoteStyle: \"double\",\n      semicolons: \"asNeeded\",\n    },\n  },\n};\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  biomeConfiguration?: BiomeConfiguration,\n) => {\n  const input = `type ${identifierPrefix} = ${code}`;\n  const javascriptFormatter = {\n    ...defaultBiomeConfiguration.javascript?.formatter,\n    ...biomeConfiguration?.javascript?.formatter,\n  };\n\n  biome.applyConfiguration(projectKey, {\n    ...defaultBiomeConfiguration,\n    ...biomeConfiguration,\n    formatter: {\n      ...defaultBiomeConfiguration.formatter,\n      ...biomeConfiguration?.formatter,\n    },\n    javascript: {\n      ...defaultBiomeConfiguration.javascript,\n      ...biomeConfiguration?.javascript,\n      formatter: javascriptFormatter,\n    },\n  });\n\n  const result = biome.formatContent(projectKey, input, {\n    filePath: virtualFormatFileName,\n  });\n\n  if (result.diagnostics.length > 0) {\n    throw new Error(\n      biome.printDiagnostics(result.diagnostics, {\n        filePath: virtualFormatFileName,\n        fileSource: input,\n      }),\n    );\n  }\n\n  return result.content.trim().substring(`type ${identifierPrefix} = `.length);\n};\n"
  ],
  "mappings": "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",
  "debugId": "914AF96172681B5164756E2164756E21",
  "names": []
}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { type CompilerHostFunctionOverrides } from "./augmenter-compiler-host.js";
-import type { Options as PrettierOptions } from "prettier";
+import type { Configuration as BiomeConfiguration } from "@biomejs/wasm-nodejs";
 import ts from "typescript";
+import { type CompilerHostFunctionOverrides } from "./augmenter-compiler-host.js";
 export type ExpandTypeOptionsBase = {
     /**
      * The type expression to expand.
@@ -12,7 +12,7 @@ export type ExpandTypeOptionsBase = {
      */
     tsCompilerOptions?: ts.CompilerOptions;
     /**
-     * Prettier options.
+     * Prettify options.
      */
     prettify?: {
         /**
@@ -21,10 +21,9 @@ export type ExpandTypeOptionsBase = {
          */
         enabled?: boolean;
         /**
-         * Prettier options. Don't forget to set the parser to "typescript".
-         * @default { parser: "typescript", semi: false }
+         * Biome formatting configuration.
          */
-        options?: PrettierOptions;
+        biomeOptions?: BiomeConfiguration;
     };
     /**
      * A record of functions to override in the compiler host. Useful for mocking

package/dist/index.js

@@ -1,3 +1,7 @@
+// src/index.ts
+import path from "node:path";
+import ts2 from "typescript";
+
 // src/augmenter-compiler-host.ts
 import ts from "typescript";
 var createAugmenterCompilerHost = (sourceFileName, codeToAdd, compilerOptions, compilerHostFunctionOverrides) => {
@@ -25,8 +29,23 @@ ${contents}`;
 };
 
 // src/code-generator.ts
-import { format } from "prettier";
+import { Biome } from "@biomejs/js-api/nodejs";
 var identifierPrefix = "__EXPAND_MY_TYPE__";
+var virtualFormatFileName = "expand-my-type.ts";
+var biome = new Biome;
+var { projectKey } = biome.openProject();
+var defaultBiomeConfiguration = {
+  formatter: {
+    enabled: true,
+    indentStyle: "space"
+  },
+  javascript: {
+    formatter: {
+      quoteStyle: "double",
+      semicolons: "asNeeded"
+    }
+  }
+};
 var createExpandCodeBlock = (typeExpression) => {
   return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
     type ${identifierPrefix}Expression = ${typeExpression};
@@ -43,18 +62,40 @@ var createExpandCodeBlock = (typeExpression) => {
     type ${identifierPrefix}AppendUnderscore<T extends string> = \`\${T}_\` extends string ? \`\${T}_\` : never;
     type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \`\${infer U}_\` ? U : never;`;
 };
-var formatTypeExpression = async (code, prettierOptions) => {
-  return (await format(`type ${identifierPrefix} = ${code}`, prettierOptions ?? {
-    parser: "typescript",
-    semi: false
-  })).trim().substring(`type ${identifierPrefix} = `.length);
+var formatTypeExpression = async (code, biomeConfiguration) => {
+  const input = `type ${identifierPrefix} = ${code}`;
+  const javascriptFormatter = {
+    ...defaultBiomeConfiguration.javascript?.formatter,
+    ...biomeConfiguration?.javascript?.formatter
+  };
+  biome.applyConfiguration(projectKey, {
+    ...defaultBiomeConfiguration,
+    ...biomeConfiguration,
+    formatter: {
+      ...defaultBiomeConfiguration.formatter,
+      ...biomeConfiguration?.formatter
+    },
+    javascript: {
+      ...defaultBiomeConfiguration.javascript,
+      ...biomeConfiguration?.javascript,
+      formatter: javascriptFormatter
+    }
+  });
+  const result = biome.formatContent(projectKey, input, {
+    filePath: virtualFormatFileName
+  });
+  if (result.diagnostics.length > 0) {
+    throw new Error(biome.printDiagnostics(result.diagnostics, {
+      filePath: virtualFormatFileName,
+      fileSource: input
+    }));
+  }
+  return result.content.trim().substring(`type ${identifierPrefix} = `.length);
 };
 
 // src/index.ts
-import path from "node:path";
-import ts2 from "typescript";
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!ts2.isIdentifier(node)) {
       return;
     }
@@ -107,14 +148,14 @@ async function expandMyType(options) {
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, ts2.TypeFormatFlags.NodeBuilderFlagsMask);
-  if (options.prettify && options.prettify.enabled === false) {
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
 export {
   expandMyType
 };
 
-//# debugId=FA40E2FF4FF7499A64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/augmenter-compiler-host.ts", "../src/code-generator.ts", "../src/index.ts"],
  "sourcesContent": [
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import type { Options as PrettierOptions } from \"prettier\";\nimport { format } from \"prettier\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  prettierOptions?: PrettierOptions,\n) => {\n  return (\n    await format(\n      `type ${identifierPrefix} = ${code}`,\n      prettierOptions ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${identifierPrefix} = `.length);\n};\n",
    "import { createAugmenterCompilerHost } from \"./augmenter-compiler-host.js\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\nimport path from \"node:path\";\nimport type { Options as PrettierOptions } from \"prettier\";\nimport ts from \"typescript\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() == 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettier options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Prettier options. Don't forget to set the parser to \"typescript\".\n     * @default { parser: \"typescript\", semi: false }\n     */\n    options?: PrettierOptions;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(expandedTypeString, options.prettify?.options);\n}\n"
  ],
  "mappings": "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",
  "debugId": "FA40E2FF4FF7499A64756E2164756E21",
  "names": []
}
+//# debugId=A899C07794769D2464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/augmenter-compiler-host.ts", "../src/code-generator.ts"],
  "sourcesContent": [
    "import path from \"node:path\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\nimport ts from \"typescript\";\nimport {\n  type CompilerHostFunctionOverrides,\n  createAugmenterCompilerHost,\n} from \"./augmenter-compiler-host.js\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.js\";\n\n/**\n * Finds the result type identifier node.\n *\n * @param node Node in which type type should be searched.\n * @returns The result type identifier node.\n */\nconst findResultIdentifierNode = (node: ts.Node): ts.Node | undefined => {\n  if (node.getChildCount() === 0) {\n    if (!ts.isIdentifier(node)) {\n      return undefined;\n    }\n\n    // Since we put the __<IDENTIFIER>__ type at the beginning of the\n    // file, we can return the first identifier we find.\n    return node;\n  }\n\n  return ts.forEachChild(node, findResultIdentifierNode);\n};\n\nexport type ExpandTypeOptionsBase = {\n  /**\n   * The type expression to expand.\n   * @example \"ReturnType<typeof myFunction>\"\n   */\n  typeExpression: string;\n\n  /**\n   * TypeScript compiler options.\n   */\n  tsCompilerOptions?: ts.CompilerOptions;\n\n  /**\n   * Prettify options.\n   */\n  prettify?: {\n    /**\n     * Whether to prettify the output.\n     * @default true\n     */\n    enabled?: boolean;\n    /**\n     * Biome formatting configuration.\n     */\n    biomeOptions?: BiomeConfiguration;\n  };\n\n  /**\n   * A record of functions to override in the compiler host. Useful for mocking\n   */\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;\n};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n};\nexport type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {\n  /**\n   * TypeScript source text to evaluate the type expression in.\n   */\n  sourceText: string;\n};\nexport type ExpandMyTypeOptions =\n  | ExpandTypeFromSourceFileOptions\n  | ExpandTypeFromSourceTextOptions;\n\nexport async function expandMyType(\n  options: ExpandTypeFromSourceTextOptions,\n): Promise<string>;\nexport async function expandMyType(\n  options: ExpandTypeFromSourceFileOptions,\n): Promise<string>;\n\n/**\n * Expands a TypeScript type expression.\n *\n * @param options\n * @returns The expanded type expression.\n */\nexport async function expandMyType(options: ExpandMyTypeOptions) {\n  if (options.typeExpression.trim() === \"\") {\n    return \"never\";\n  }\n\n  if (\"sourceText\" in options) {\n    const dummyFileName = \"expand-my-type-dummy.ts\";\n\n    return expandMyType({\n      sourceFileName: dummyFileName,\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile(fileName: string) {\n          if (path.basename(fileName) === dummyFileName) {\n            return options.sourceText;\n          }\n\n          return ts.sys.readFile(fileName);\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n      prettify: options.prettify,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    strictNullChecks: true,\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\n  };\n\n  if (!tsCompilerOptions.strictNullChecks) {\n    throw new Error(\"strictNullChecks must be enabled!\");\n  }\n\n  const compilerHost = createAugmenterCompilerHost(\n    resolvedSourceFileName,\n    createExpandCodeBlock(options.typeExpression),\n    tsCompilerOptions,\n    options.compilerHostFunctionOverrides,\n  );\n\n  const program = ts.createProgram(\n    [resolvedSourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(resolvedSourceFileName);\n  if (!sourceFile) {\n    throw new Error(\"Source file not found!\");\n  }\n\n  const resultIdentifierNode = findResultIdentifierNode(sourceFile);\n  if (!resultIdentifierNode) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(resultIdentifierNode),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify?.enabled === false) {\n    return expandedTypeString;\n  }\n\n  return formatTypeExpression(\n    expandedTypeString,\n    options.prettify?.biomeOptions,\n  );\n}\n",
    "import ts from \"typescript\";\n\ntype ExtractFunctions<T, K extends keyof T = keyof T> = {\n  [P in K]: Extract<T[P], (...args: never[]) => unknown>;\n};\nexport type CompilerHostFunctionOverrides = Partial<\n  ExtractFunctions<ts.CompilerHost>\n>;\n\n/**\n * Creates a custom compiler host that augments the specified source file for expanding a type expression.\n *\n * @param sourceFileName Name of the source file to augment.\n * @param codeToAdd Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createAugmenterCompilerHost = (\n  sourceFileName: string,\n  codeToAdd: string,\n  compilerOptions?: ts.CompilerOptions,\n  compilerHostFunctionOverrides?: CompilerHostFunctionOverrides,\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);\n  const overrides = compilerHostFunctionOverrides ?? {};\n\n  for (const key of Object.keys(overrides) as Array<\n    keyof CompilerHostFunctionOverrides\n  >) {\n    const override = overrides[key];\n\n    if (override) {\n      (customCompilerHost as unknown as Record<string, unknown>)[key] =\n        override;\n    }\n  }\n\n  const originalReadFile = customCompilerHost.readFile;\n\n  customCompilerHost.readFile = (fileName) => {\n    const contents = originalReadFile(fileName);\n\n    if (contents === undefined) {\n      return contents;\n    }\n\n    if (fileName !== sourceFileName) {\n      return contents;\n    }\n\n    return `${codeToAdd}\\n${contents}`;\n  };\n\n  return customCompilerHost;\n};\n",
    "import { Biome } from \"@biomejs/js-api/nodejs\";\nimport type { Configuration as BiomeConfiguration } from \"@biomejs/wasm-nodejs\";\n\nconst identifierPrefix = \"__EXPAND_MY_TYPE__\";\nconst virtualFormatFileName = \"expand-my-type.ts\";\nconst biome = new Biome();\nconst { projectKey } = biome.openProject();\n\nconst defaultBiomeConfiguration: BiomeConfiguration = {\n  formatter: {\n    enabled: true,\n    indentStyle: \"space\",\n  },\n  javascript: {\n    formatter: {\n      quoteStyle: \"double\",\n      semicolons: \"asNeeded\",\n    },\n  },\n};\n\nexport const createExpandCodeBlock = (typeExpression: string) => {\n  // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n  return `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;\n    type ${identifierPrefix}Expression = ${typeExpression};\n\n    type ${identifierPrefix}Expand<T> = \n        T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : T extends Promise<infer U> ? Promise<${identifierPrefix}ExpandTypeArgument<U>>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\n\n    type ${identifierPrefix}ExpandTypeArgument<T> = [T & {}] extends [never] ? T : T & {} extends void ? T : ${identifierPrefix}Expand<T & {}>;\n\n    // Forces a union of string literal types to be expanded\n    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;\n    type ${identifierPrefix}AppendUnderscore<T extends string> = \\`\\${T}_\\` extends string ? \\`\\${T}_\\` : never;\n    type ${identifierPrefix}RemoveUnderscore<T extends string> = T extends \\`\\${infer U}_\\` ? U : never;`;\n};\n\nexport const formatTypeExpression = async (\n  code: string,\n  biomeConfiguration?: BiomeConfiguration,\n) => {\n  const input = `type ${identifierPrefix} = ${code}`;\n  const javascriptFormatter = {\n    ...defaultBiomeConfiguration.javascript?.formatter,\n    ...biomeConfiguration?.javascript?.formatter,\n  };\n\n  biome.applyConfiguration(projectKey, {\n    ...defaultBiomeConfiguration,\n    ...biomeConfiguration,\n    formatter: {\n      ...defaultBiomeConfiguration.formatter,\n      ...biomeConfiguration?.formatter,\n    },\n    javascript: {\n      ...defaultBiomeConfiguration.javascript,\n      ...biomeConfiguration?.javascript,\n      formatter: javascriptFormatter,\n    },\n  });\n\n  const result = biome.formatContent(projectKey, input, {\n    filePath: virtualFormatFileName,\n  });\n\n  if (result.diagnostics.length > 0) {\n    throw new Error(\n      biome.printDiagnostics(result.diagnostics, {\n        filePath: virtualFormatFileName,\n        fileSource: input,\n      }),\n    );\n  }\n\n  return result.content.trim().substring(`type ${identifierPrefix} = `.length);\n};\n"
  ],
  "mappings": "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",
  "debugId": "A899C07794769D2464756E2164756E21",
  "names": []
}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expand-my-type",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Expand TypeScript type expressions programmatically",
   "keywords": [
     "expand",
@@ -38,21 +38,22 @@
     "build:cjs": "bun build ./src/index.ts --target node --format cjs --packages external --outfile ./dist/index.cjs --sourcemap=inline",
     "build:esm": "bun build ./src/index.ts ./src/cli.ts --target node --format esm --packages external --outdir ./dist --root ./src --sourcemap=inline",
     "build:types": "tsc -p tsconfig.build.json",
-    "check": "bun run typecheck && bun test ./src/index.test.ts",
+    "check": "bun run lint && bun run typecheck && bun run test",
+    "fix": "biome check --write .",
     "clean": "rm -rf dist",
     "deps:update": "bun update --latest",
-    "format": "prettier --write .",
+    "format": "bun run fix",
+    "lint": "bunx @biomejs/biome check .",
     "test": "bun test ./src/index.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "prettier": "^3.8.1",
+    "@biomejs/js-api": "^4.0.0",
+    "@biomejs/wasm-nodejs": "^2.4.11",
     "typescript": "^6.0.2"
   },
   "devDependencies": {
-    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
-    "@types/node": "^22.19.11",
-    "prettier-plugin-packagejson": "^2.5.22"
-  },
-  "packageManager": "bun@1.3.11"
+    "@biomejs/biome": "2.4.11",
+    "@types/node": "^25.5.2"
+  }
 }