expand-my-type 0.6.9 → 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,39 @@ 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
+bun install
+bun run check
+bun run build
+bun run deps:update
+```
+
 ## How It Works
 
 Expand My Type uses the following utility types to expand the type expression:
@@ -169,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

@@ -0,0 +1,16 @@
+import ts from "typescript";
+type ExtractFunctions<T, K extends keyof T = keyof T> = {
+    [P in K]: Extract<T[P], (...args: never[]) => unknown>;
+};
+export type CompilerHostFunctionOverrides = Partial<ExtractFunctions<ts.CompilerHost>>;
+/**
+ * Creates a custom compiler host that augments the specified source file for expanding a type expression.
+ *
+ * @param sourceFileName Name of the source file to augment.
+ * @param codeToAdd Type expression.
+ * @param compilerOptions TypeScript compiler options.
+ * @param compilerHostFunctionOverrides A record of functions to override in the compiler host. Useful for mocking.
+ * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.
+ */
+export declare const createAugmenterCompilerHost: (sourceFileName: string, codeToAdd: string, compilerOptions?: ts.CompilerOptions, compilerHostFunctionOverrides?: CompilerHostFunctionOverrides) => ts.CompilerHost;
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -1,19 +1,27 @@
 #!/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 = (sourceFileName2, codeToAdd, compilerOptions, compilerHostFunctionOverrides) => {
+var createAugmenterCompilerHost = (sourceFileName, codeToAdd, compilerOptions, compilerHostFunctionOverrides) => {
   const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);
-  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {
-    customCompilerHost[key] = compilerHostFunctionOverrides[key];
+  const overrides = compilerHostFunctionOverrides ?? {};
+  for (const key of Object.keys(overrides)) {
+    const override = overrides[key];
+    if (override) {
+      customCompilerHost[key] = override;
+    }
   }
   const originalReadFile = customCompilerHost.readFile;
   customCompilerHost.readFile = (fileName) => {
     const contents = originalReadFile(fileName);
-    if (contents === void 0) {
+    if (contents === undefined) {
       return contents;
     }
-    if (fileName !== sourceFileName2) {
+    if (fileName !== sourceFileName) {
       return contents;
     }
     return `${codeToAdd}
@@ -23,11 +31,26 @@ ${contents}`;
 };
 
 // src/code-generator.ts
-import { format } from "prettier";
+import { Biome } from "@biomejs/js-api/nodejs";
 var identifierPrefix = "__EXPAND_MY_TYPE__";
-var createExpandCodeBlock = (typeExpression2) => {
+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 = ${typeExpression2};
+    type ${identifierPrefix}Expression = ${typeExpression};
 
     type ${identifierPrefix}Expand<T> = 
         T extends (...args: infer A) => infer R ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>
@@ -41,23 +64,42 @@ var createExpandCodeBlock = (typeExpression2) => {
     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
+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
     }
-  )).trim().substring(`type ${identifierPrefix} = `.length);
+  });
+  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 "path";
-import ts2 from "typescript";
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!ts2.isIdentifier(node)) {
-      return void 0;
+      return;
     }
     return node;
   }
@@ -96,17 +138,8 @@ async function expandMyType(options) {
   if (!tsCompilerOptions.strictNullChecks) {
     throw new Error("strictNullChecks must be enabled!");
   }
-  const compilerHost = createAugmenterCompilerHost(
-    resolvedSourceFileName,
-    createExpandCodeBlock(options.typeExpression),
-    tsCompilerOptions,
-    options.compilerHostFunctionOverrides
-  );
-  const program = ts2.createProgram(
-    [resolvedSourceFileName],
-    tsCompilerOptions,
-    compilerHost
-  );
+  const compilerHost = createAugmenterCompilerHost(resolvedSourceFileName, createExpandCodeBlock(options.typeExpression), tsCompilerOptions, options.compilerHostFunctionOverrides);
+  const program = ts2.createProgram([resolvedSourceFileName], tsCompilerOptions, compilerHost);
   const sourceFile = program.getSourceFile(resolvedSourceFileName);
   if (!sourceFile) {
     throw new Error("Source file not found!");
@@ -116,52 +149,48 @@ async function expandMyType(options) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
-  const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(resultIdentifierNode),
-    void 0,
-    ts2.TypeFormatFlags.NodeBuilderFlagsMask
-  );
-  if (options.prettify && options.prettify.enabled === false) {
+  const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, ts2.TypeFormatFlags.NodeBuilderFlagsMask);
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
 
 // src/cli.ts
-import { parseArgs } from "util";
+import { parseArgs } from "node:util";
 import ts3 from "typescript";
 var tryParse = (options) => {
-  let result2;
+  let result;
   try {
-    result2 = parseArgs({
+    result = parseArgs({
       options,
       tokens: true,
       allowPositionals: true
     });
-  } catch (error2) {
+  } catch (error) {
     return {
-      error: error2,
+      error: error instanceof Error ? error : new Error(String(error)),
       values: {},
       positionals: []
     };
   }
-  const { tokens, values: values2, positionals: positionals2 } = result2;
+  const { tokens, values, positionals } = result;
   for (const token of tokens ?? []) {
     if (token.kind === "option-terminator" || token.kind === "positional") {
       continue;
     }
     if (token.name.startsWith("no-")) {
       const positiveName = token.name.slice("no-".length);
-      values2[positiveName] = false;
-      delete values2[token.name];
+      values[positiveName] = false;
+      delete values[token.name];
     } else {
-      values2[token.name] = token.value ?? true;
+      values[token.name] = token.value ?? true;
     }
   }
   return {
-    error: void 0,
-    values: values2,
-    positionals: positionals2
+    error: undefined,
+    values,
+    positionals
   };
 };
 var { error, values, positionals } = tryParse({
@@ -192,29 +221,27 @@ var usagePrompt = [
   "  expand-my-type [options] <source-file> <expression>",
   "",
   "Options:",
-  "  -h, --help			Show this help message",
-  "  -p, --prettify		Prettify the output (default)",
-  "  -P, --no-prettify		Do not prettify the output",
-  "  -c, --tsconfig <file>		Use the specified tsconfig.json file"
-].join("\n");
-if (positionals.length !== 2) {
-  console.error(usagePrompt);
-  process.exit(1);
-}
+  "  -h, --help\t\t\tShow this help message",
+  "  -p, --prettify\t\tPrettify the output (default)",
+  "  -P, --no-prettify\t\tDo not prettify the output",
+  "  -c, --tsconfig <file>\t\tUse the specified tsconfig.json file"
+].join(`
+`);
 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);
-  const compilerOptions = ts3.parseJsonConfigFileContent(
-    configFile.config,
-    ts3.sys,
-    "./"
-  );
+  const compilerOptions = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, "./");
   tsParsedCommandLine = compilerOptions;
 }
 var result = await expandMyType({
@@ -226,4 +253,6 @@ var result = await expandMyType({
   tsCompilerOptions: tsParsedCommandLine?.options
 });
 console.log(result);
-//# 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  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {\n    customCompilerHost[key] = compilerHostFunctionOverrides![key];\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.ts\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.ts\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.ts\";\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.ts\";\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,\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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",
  "names": ["sourceFileName", "typeExpression", "ts", "ts", "result", "error", "values", "positionals"]
}

+
+//# 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

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

package/dist/index.cjs

@@ -1,49 +1,89 @@
 var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
 };
-var __copyProps = (to, from, except, desc) => {
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
   }
-  return to;
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var exports_src = {};
+__export(exports_src, {
   expandMyType: () => expandMyType
 });
-module.exports = __toCommonJS(index_exports);
+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"), 1);
+var import_typescript = __toESM(require("typescript"));
 var createAugmenterCompilerHost = (sourceFileName, codeToAdd, compilerOptions, compilerHostFunctionOverrides) => {
   const customCompilerHost = import_typescript.default.createCompilerHost(compilerOptions ?? {}, true);
-  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {
-    customCompilerHost[key] = compilerHostFunctionOverrides[key];
+  const overrides = compilerHostFunctionOverrides ?? {};
+  for (const key of Object.keys(overrides)) {
+    const override = overrides[key];
+    if (override) {
+      customCompilerHost[key] = override;
+    }
   }
   const originalReadFile = customCompilerHost.readFile;
   customCompilerHost.readFile = (fileName) => {
     const contents = originalReadFile(fileName);
-    if (contents === void 0) {
+    if (contents === undefined) {
       return contents;
     }
     if (fileName !== sourceFileName) {
@@ -56,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};
@@ -74,23 +129,42 @@ 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 (0, import_prettier.format)(
-    `type ${identifierPrefix} = ${code}`,
-    prettierOptions ?? {
-      parser: "typescript",
-      semi: false
+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
     }
-  )).trim().substring(`type ${identifierPrefix} = `.length);
+  });
+  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("path"), 1);
-var import_typescript2 = __toESM(require("typescript"), 1);
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!import_typescript2.default.isIdentifier(node)) {
-      return void 0;
+      return;
     }
     return node;
   }
@@ -129,17 +203,8 @@ async function expandMyType(options) {
   if (!tsCompilerOptions.strictNullChecks) {
     throw new Error("strictNullChecks must be enabled!");
   }
-  const compilerHost = createAugmenterCompilerHost(
-    resolvedSourceFileName,
-    createExpandCodeBlock(options.typeExpression),
-    tsCompilerOptions,
-    options.compilerHostFunctionOverrides
-  );
-  const program = import_typescript2.default.createProgram(
-    [resolvedSourceFileName],
-    tsCompilerOptions,
-    compilerHost
-  );
+  const compilerHost = createAugmenterCompilerHost(resolvedSourceFileName, createExpandCodeBlock(options.typeExpression), tsCompilerOptions, options.compilerHostFunctionOverrides);
+  const program = import_typescript2.default.createProgram([resolvedSourceFileName], tsCompilerOptions, compilerHost);
   const sourceFile = program.getSourceFile(resolvedSourceFileName);
   if (!sourceFile) {
     throw new Error("Source file not found!");
@@ -149,18 +214,12 @@ async function expandMyType(options) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
-  const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(resultIdentifierNode),
-    void 0,
-    import_typescript2.default.TypeFormatFlags.NodeBuilderFlagsMask
-  );
-  if (options.prettify && options.prettify.enabled === false) {
+  const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, import_typescript2.default.TypeFormatFlags.NodeBuilderFlagsMask);
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  expandMyType
-});
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/augmenter-compiler-host.ts", "../src/code-generator.ts"],
  "sourcesContent": ["import { createAugmenterCompilerHost } from \"./augmenter-compiler-host.ts\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.ts\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.ts\";\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", "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  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {\n    customCompilerHost[key] = compilerHostFunctionOverrides![key];\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"],
  "mappings": "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",
  "names": ["ts", "import_typescript", "ts", "path"]
}

+
+//# 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,12 +1,7 @@
-import ts from 'typescript';
-import { Options } from 'prettier';
-
-type ExtractFunctions<T, K extends keyof T = keyof T> = {
-    [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;
-};
-type CompilerHostFunctionOverrides = Partial<ExtractFunctions<ts.CompilerHost>>;
-
-type ExpandTypeOptionsBase = {
+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.
      * @example "ReturnType<typeof myFunction>"
@@ -17,7 +12,7 @@ type ExpandTypeOptionsBase = {
      */
     tsCompilerOptions?: ts.CompilerOptions;
     /**
-     * Prettier options.
+     * Prettify options.
      */
     prettify?: {
         /**
@@ -26,30 +21,27 @@ type ExpandTypeOptionsBase = {
          */
         enabled?: boolean;
         /**
-         * Prettier options. Don't forget to set the parser to "typescript".
-         * @default { parser: "typescript", semi: false }
+         * Biome formatting configuration.
          */
-        options?: Options;
+        biomeOptions?: BiomeConfiguration;
     };
     /**
      * A record of functions to override in the compiler host. Useful for mocking
      */
     compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;
 };
-type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {
+export type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {
     /**
      * Name of the source file to evaluate the type expression in.
      */
     sourceFileName: string;
 };
-type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {
+export type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {
     /**
      * TypeScript source text to evaluate the type expression in.
      */
     sourceText: string;
 };
-type ExpandMyTypeOptions = ExpandTypeFromSourceFileOptions | ExpandTypeFromSourceTextOptions;
-declare function expandMyType(options: ExpandTypeFromSourceTextOptions): Promise<string>;
-declare function expandMyType(options: ExpandTypeFromSourceFileOptions): Promise<string>;
-
-export { type ExpandMyTypeOptions, type ExpandTypeFromSourceFileOptions, type ExpandTypeFromSourceTextOptions, type ExpandTypeOptionsBase, expandMyType };
+export type ExpandMyTypeOptions = ExpandTypeFromSourceFileOptions | ExpandTypeFromSourceTextOptions;
+export declare function expandMyType(options: ExpandTypeFromSourceTextOptions): Promise<string>;
+export declare function expandMyType(options: ExpandTypeFromSourceFileOptions): Promise<string>;

package/dist/index.js

@@ -1,14 +1,22 @@
+// 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) => {
   const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {}, true);
-  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {
-    customCompilerHost[key] = compilerHostFunctionOverrides[key];
+  const overrides = compilerHostFunctionOverrides ?? {};
+  for (const key of Object.keys(overrides)) {
+    const override = overrides[key];
+    if (override) {
+      customCompilerHost[key] = override;
+    }
   }
   const originalReadFile = customCompilerHost.readFile;
   customCompilerHost.readFile = (fileName) => {
     const contents = originalReadFile(fileName);
-    if (contents === void 0) {
+    if (contents === undefined) {
       return contents;
     }
     if (fileName !== sourceFileName) {
@@ -21,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};
@@ -39,23 +62,42 @@ 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
+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
     }
-  )).trim().substring(`type ${identifierPrefix} = `.length);
+  });
+  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 "path";
-import ts2 from "typescript";
 var findResultIdentifierNode = (node) => {
-  if (node.getChildCount() == 0) {
+  if (node.getChildCount() === 0) {
     if (!ts2.isIdentifier(node)) {
-      return void 0;
+      return;
     }
     return node;
   }
@@ -94,17 +136,8 @@ async function expandMyType(options) {
   if (!tsCompilerOptions.strictNullChecks) {
     throw new Error("strictNullChecks must be enabled!");
   }
-  const compilerHost = createAugmenterCompilerHost(
-    resolvedSourceFileName,
-    createExpandCodeBlock(options.typeExpression),
-    tsCompilerOptions,
-    options.compilerHostFunctionOverrides
-  );
-  const program = ts2.createProgram(
-    [resolvedSourceFileName],
-    tsCompilerOptions,
-    compilerHost
-  );
+  const compilerHost = createAugmenterCompilerHost(resolvedSourceFileName, createExpandCodeBlock(options.typeExpression), tsCompilerOptions, options.compilerHostFunctionOverrides);
+  const program = ts2.createProgram([resolvedSourceFileName], tsCompilerOptions, compilerHost);
   const sourceFile = program.getSourceFile(resolvedSourceFileName);
   if (!sourceFile) {
     throw new Error("Source file not found!");
@@ -114,17 +147,15 @@ async function expandMyType(options) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
-  const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(resultIdentifierNode),
-    void 0,
-    ts2.TypeFormatFlags.NodeBuilderFlagsMask
-  );
-  if (options.prettify && options.prettify.enabled === false) {
+  const expandedTypeString = typeChecker.typeToString(typeChecker.getTypeAtLocation(resultIdentifierNode), undefined, ts2.TypeFormatFlags.NodeBuilderFlagsMask);
+  if (options.prettify?.enabled === false) {
     return expandedTypeString;
   }
-  return formatTypeExpression(expandedTypeString, options.prettify?.options);
+  return formatTypeExpression(expandedTypeString, options.prettify?.biomeOptions);
 }
 export {
   expandMyType
 };
-//# 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  for (const key of Object.keys(compilerHostFunctionOverrides ?? {})) {\n    customCompilerHost[key] = compilerHostFunctionOverrides![key];\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.ts\";\nimport { type CompilerHostFunctionOverrides } from \"./augmenter-compiler-host.ts\";\nimport {\n  createExpandCodeBlock,\n  formatTypeExpression,\n} from \"./code-generator.ts\";\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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",
  "names": ["ts"]
}

+
+//# 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.6.9",
+  "version": "0.8.0",
   "description": "Expand TypeScript type expressions programmatically",
   "keywords": [
     "expand",
@@ -20,14 +20,9 @@
   "type": "module",
   "exports": {
     ".": {
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      },
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     }
   },
   "main": "dist/index.cjs",
@@ -36,30 +31,29 @@
     "expand-my-type": "./dist/cli.js"
   },
   "files": [
-    "dist/index.cjs",
-    "dist/index.d.cts",
-    "dist/index.d.ts",
-    "dist/index.js",
-    "dist/cli.js"
+    "dist"
   ],
   "scripts": {
-    "bundle-cli": "tsup ./src/cli.ts --format esm --sourcemap inline --silent",
-    "bundle-lib": "tsup ./src/index.ts --format cjs,esm --dts --clean --sourcemap inline --silent",
-    "format": "prettier --write .",
-    "prepare": "npm run bundle-lib && npm run bundle-cli",
-    "pretest": "tsc",
-    "test": "tsx --test --test-reporter spec ./src/index.test.ts"
+    "build": "bun run clean && bun run build:esm && bun run build:cjs && bun run build:types",
+    "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 lint && bun run typecheck && bun run test",
+    "fix": "biome check --write .",
+    "clean": "rm -rf dist",
+    "deps:update": "bun update --latest",
+    "format": "bun run fix",
+    "lint": "bunx @biomejs/biome check .",
+    "test": "bun test ./src/index.test.ts",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "prettier": "^3.8.1",
-    "typescript": "^5.9.3"
+    "@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",
-    "npm-check-updates": "^17.1.18",
-    "prettier-plugin-packagejson": "^2.5.22",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0"
+    "@biomejs/biome": "2.4.11",
+    "@types/node": "^25.5.2"
   }
 }

package/dist/index.d.cts

@@ -1,55 +0,0 @@
-import ts from 'typescript';
-import { Options } from 'prettier';
-
-type ExtractFunctions<T, K extends keyof T = keyof T> = {
-    [P in K]: T[P] extends (...args: any[]) => any ? T[P] : never;
-};
-type CompilerHostFunctionOverrides = Partial<ExtractFunctions<ts.CompilerHost>>;
-
-type ExpandTypeOptionsBase = {
-    /**
-     * The type expression to expand.
-     * @example "ReturnType<typeof myFunction>"
-     */
-    typeExpression: string;
-    /**
-     * TypeScript compiler options.
-     */
-    tsCompilerOptions?: ts.CompilerOptions;
-    /**
-     * Prettier options.
-     */
-    prettify?: {
-        /**
-         * Whether to prettify the output.
-         * @default true
-         */
-        enabled?: boolean;
-        /**
-         * Prettier options. Don't forget to set the parser to "typescript".
-         * @default { parser: "typescript", semi: false }
-         */
-        options?: Options;
-    };
-    /**
-     * A record of functions to override in the compiler host. Useful for mocking
-     */
-    compilerHostFunctionOverrides?: CompilerHostFunctionOverrides;
-};
-type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {
-    /**
-     * Name of the source file to evaluate the type expression in.
-     */
-    sourceFileName: string;
-};
-type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {
-    /**
-     * TypeScript source text to evaluate the type expression in.
-     */
-    sourceText: string;
-};
-type ExpandMyTypeOptions = ExpandTypeFromSourceFileOptions | ExpandTypeFromSourceTextOptions;
-declare function expandMyType(options: ExpandTypeFromSourceTextOptions): Promise<string>;
-declare function expandMyType(options: ExpandTypeFromSourceFileOptions): Promise<string>;
-
-export { type ExpandMyTypeOptions, type ExpandTypeFromSourceFileOptions, type ExpandTypeFromSourceTextOptions, type ExpandTypeOptionsBase, expandMyType };