expand-my-type 0.4.0 → 0.5.0

package/README.md

@@ -8,25 +8,14 @@
 
 In TypeScript, expanding a type (also known as computing, resolving,
 simplifying, unpacking, or unwrapping) refers to converting a type expression
-into a flattened type that doesn't reference other types. That can be achieved
-by defining [a utility type][compute-type]:
+into a flattened type that doesn't reference other types. This is mostly done
+to improve the readability of type hints shown in editors/IDEs.
 
-```typescript
-type Compute<A> = { [K in keyof A]: Compute<A[K]> } & {};
-```
-
-And wrapping the type expression with it:
-
-```typescript
-type ExpandedType = Compute<SomeType>;
-```
-
-This is mostly done to improve the readability of type hints shown in editors/IDEs.
-
-**Expand My Type** provides a programmatic way to do the same
-(see [limitations](#limitations)). It gets the source code as input, along with
-a type expression and returns the expanded form as a string. That can be useful
-for code-generation, testing, and debugging complex type errors.
+**Expand My Type** provides a programmatic way to expand type expressions in
+TypeScript (see [How It Works](#how-it-works) section for more information). It
+gets the source code as input, along with a type expression and returns the
+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
@@ -148,43 +137,29 @@ the following ways:
    /* { a: string; b: number } */
    ```
 
-## Limitations
+## How It Works
 
-Expand My Type uses the following utility type to expand the type expression:
+Expand My Type uses the following utility types to expand the type expression:
 
 ```typescript
+// Expands a type expression
 type Expand<T> = T extends (...args: infer A) => infer R
   ? (...args: Expand<A>) => Expand<R>
-  : { [K in keyof T]: Expand<T[K]> } & {};
-```
-
-As a result, the output it generates is what the TypeScript compiler would
-infer from wrapping the type expression with the `Expand` utility type.
-This approach comes with some limitations.
-
-### Type References to Union String Literal Types
-
-Type references to union string literal types are not expanded. For example,
-expanding T in the following snippet:
-
-```typescript
-type T = { s: S };
-type S = "a" | "b";
+  : {
+      [K in keyof T]: T[K] extends string ? ExpandString<T[K]> : Expand<T[K]>;
+    } & {};
+
+// Forces a union of string literal types to be expanded
+type ExpandString<T extends string> = RemoveUnderscore<AppendUnderscore<T>>;
+type AppendUnderscore<T extends string> = `${T}_` extends string
+  ? `${T}_`
+  : never;
+type RemoveUnderscore<T extends string> = T extends `${infer U}_` ? U : never;
 ```
 
-outputs `{ s: S }` instead of `{ s: "a" | "b" }`.
-
-### Recursive Type References
-
-Expanding recursive type references can lead to infinite loops. When an infinite
-loop occurs, the generated output gets truncated. Therefore, prettifying the
-truncated output will throw an error.
-
-## Contributions
-
-Considering the limitations above, contributions to improve the expansion
-utility type are more than welcome.
+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.
 
-[compute-type]: https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts
 [prettier]: https://prettier.io
 [ts-compiler-api]: https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API

package/dist/cli.js

@@ -31,7 +31,12 @@ var createExpandCodeBlock = (typeExpression2) => {
 
     type ${identifierPrefix}Expand<T> = T extends (...args: infer A) => infer R
       ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>
-      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;
+      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};
+
+    // Forces a union of string literal types to be expanded
+    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;
+    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(
@@ -46,14 +51,14 @@ var formatTypeExpression = async (code, prettierOptions) => {
 // src/index.ts
 import path from "node:path";
 import ts2 from "typescript";
-var findTypeExpanderResultNode = (node) => {
+var findResultIdentifierNode = (node) => {
   if (node.getChildCount() == 0) {
     if (!ts2.isIdentifier(node)) {
       return void 0;
     }
     return node;
   }
-  return ts2.forEachChild(node, findTypeExpanderResultNode);
+  return ts2.forEachChild(node, findResultIdentifierNode);
 };
 async function expandMyType(options) {
   if (options.typeExpression.trim() === "") {
@@ -94,13 +99,13 @@ async function expandMyType(options) {
   if (!sourceFile) {
     throw new Error("Source file not found!");
   }
-  const firstIdentifier = findTypeExpanderResultNode(sourceFile);
-  if (!firstIdentifier) {
+  const resultIdentifierNode = findResultIdentifierNode(sourceFile);
+  if (!resultIdentifierNode) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(firstIdentifier),
+    typeChecker.getTypeAtLocation(resultIdentifierNode),
     void 0,
     ts2.TypeFormatFlags.NodeBuilderFlagsMask
   );
@@ -209,4 +214,4 @@ 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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;\n};\n\nexport const createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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 node that represents the TYPE_EXPANDER_RESULT type.\n *\n * @param node Node in which the TYPE_EXPANDER_RESULT type should be searched.\n * @returns The node that represents the TYPE_EXPANDER_RESULT type.\n */\nconst findTypeExpanderResultNode = (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, findTypeExpanderResultNode);\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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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 firstIdentifier = findTypeExpanderResultNode(sourceFile);\n  if (!firstIdentifier) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\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"]
}

+//# 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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\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 createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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": ";;;AAAA,OAAO,QAAQ;AAkBR,IAAM,8BAA8B,CACzCA,iBACA,WACA,iBACA,kCACG;AACH,QAAM,qBAAqB,GAAG,mBAAmB,mBAAmB,CAAC,GAAG,IAAI;AAC5E,aAAW,OAAO,OAAO,KAAK,iCAAiC,CAAC,CAAC,GAAG;AAClE,uBAAmB,GAAG,IAAI,8BAA+B,GAAG;AAAA,EAC9D;AAEA,QAAM,mBAAmB,mBAAmB;AAE5C,qBAAmB,WAAW,CAAC,aAAa;AAC1C,UAAM,WAAW,iBAAiB,QAAQ;AAE1C,QAAI,aAAa,QAAW;AAC1B,aAAO;AAAA,IACT;AAEA,QAAI,aAAaA,iBAAgB;AAC/B,aAAO;AAAA,IACT;AAEA,WAAO,GAAG,SAAS;AAAA,EAAK,QAAQ;AAAA,EAClC;AAEA,SAAO;AACT;;;AC7CA,SAAS,cAAc;AAEvB,IAAM,mBAAmB;AAElB,IAAM,wBAAwB,CAACC,oBAA2B;AAE/D,SAAO,QAAQ,gBAAgB,YAAY,gBAAgB,UAAU,gBAAgB;AAAA,WAC5E,gBAAgB,gBAAgBA,eAAc;AAAA;AAAA,WAE9C,gBAAgB;AAAA,oBACP,gBAAgB,iBAAiB,gBAAgB;AAAA,kDACnB,gBAAgB,wBAAwB,gBAAgB;AAAA;AAAA;AAAA,WAG/F,gBAAgB,oCAAoC,gBAAgB,oBAAoB,gBAAgB;AAAA,WACxG,gBAAgB;AAAA,WAChB,gBAAgB;AAC3B;AAMO,IAAM,uBAAuB,OAClC,MACA,oBACG;AACH,UACE,MAAM;AAAA,IACJ,QAAQ,gBAAgB,MAAM,IAAI;AAAA,IAClC,mBAAmB;AAAA,MACjB,QAAQ;AAAA,MACR,MAAM;AAAA,IACR;AAAA,EACF,GAEC,KAAK,EACL,UAAU,QAAQ,gBAAgB,MAAM,MAAM;AACnD;;;ACjCA,OAAO,UAAU;AAEjB,OAAOC,SAAQ;AAQf,IAAM,2BAA2B,CAAC,SAAuC;AACvE,MAAI,KAAK,cAAc,KAAK,GAAG;AAC7B,QAAI,CAACA,IAAG,aAAa,IAAI,GAAG;AAC1B,aAAO;AAAA,IACT;AAIA,WAAO;AAAA,EACT;AAEA,SAAOA,IAAG,aAAa,MAAM,wBAAwB;AACvD;AAgEA,eAAsB,aAAa,SAA8B;AAC/D,MAAI,QAAQ,eAAe,KAAK,MAAM,IAAI;AACxC,WAAO;AAAA,EACT;AAEA,MAAI,gBAAgB,SAAS;AAC3B,WAAO,aAAa;AAAA,MAClB,gBAAgB;AAAA,MAChB,gBAAgB,QAAQ;AAAA,MACxB,+BAA+B;AAAA,QAC7B,WAAW;AACT,iBAAO,QAAQ;AAAA,QACjB;AAAA,MACF;AAAA,MACA,mBAAmB,QAAQ;AAAA,IAC7B,CAAC;AAAA,EACH;AAEA,QAAM,yBAAyB,KAAK,QAAQ,QAAQ,cAAc;AAElE,QAAM,oBAAoB,QAAQ,qBAAqB;AAAA,IACrD,QAAQ;AAAA,IAER,8BAA8B;AAAA,IAC9B,0BAA0B;AAAA,IAC1B,4BAA4B;AAAA,IAC5B,SAAS;AAAA,EACX;AAEA,QAAM,eAAe;AAAA,IACnB;AAAA,IACA,sBAAsB,QAAQ,cAAc;AAAA,IAC5C;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,QAAM,UAAUA,IAAG;AAAA,IACjB,CAAC,sBAAsB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,cAAc,sBAAsB;AAC/D,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,QAAM,uBAAuB,yBAAyB,UAAU;AAChE,MAAI,CAAC,sBAAsB;AACzB,UAAM,IAAI,MAAM,gBAAgB;AAAA,EAClC;AAEA,QAAM,cAAc,QAAQ,eAAe;AAC3C,QAAM,qBAAqB,YAAY;AAAA,IACrC,YAAY,kBAAkB,oBAAoB;AAAA,IAClD;AAAA,IACAA,IAAG,gBAAgB;AAAA,EACrB;AAEA,MAAI,QAAQ,YAAY,QAAQ,SAAS,YAAY,OAAO;AAC1D,WAAO;AAAA,EACT;AAEA,SAAO,qBAAqB,oBAAoB,QAAQ,UAAU,OAAO;AAC3E;;;AC1JA,SAAS,iBAAuC;AAChD,OAAOC,SAAQ;AAQf,IAAM,WAAW,CAOf,YAC6D;AAC7D,MAAIC;AACJ,MAAI;AACF,IAAAA,UAAS,UAAU;AAAA,MACjB;AAAA,MACA,QAAQ;AAAA,MACR,kBAAkB;AAAA,IACpB,CAAC;AAAA,EACH,SAASC,QAAO;AACd,WAAO;AAAA,MACL,OAAAA;AAAA,MACA,QAAQ,CAAC;AAAA,MACT,aAAa,CAAC;AAAA,IAChB;AAAA,EACF;AAEA,QAAM,EAAE,QAAQ,QAAAC,SAAQ,aAAAC,aAAY,IAAIH;AAGxC,aAAW,SAAS,UAAU,CAAC,GAAG;AAChC,QAAI,MAAM,SAAS,uBAAuB,MAAM,SAAS,cAAc;AACrE;AAAA,IACF;AAEA,QAAI,MAAM,KAAK,WAAW,KAAK,GAAG;AAEhC,YAAM,eAAe,MAAM,KAAK,MAAM,MAAM,MAAM;AAClD,MAAAE,QAAO,YAAY,IAAI;AACvB,aAAOA,QAAO,MAAM,IAAI;AAAA,IAC1B,OAAO;AAEL,MAAAA,QAAO,MAAM,IAAI,IAAI,MAAM,SAAS;AAAA,IACtC;AAAA,EACF;AAEA,SAAO;AAAA,IACL,OAAO;AAAA,IACP,QAAQA;AAAA,IACR,aAAAC;AAAA,EACF;AACF;AAEA,IAAM,EAAE,OAAO,QAAQ,YAAY,IAAI,SAAiB;AAAA,EACtD,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,EACX;AAAA,EACA,eAAe;AAAA,IACb,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AAAA,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,EACT;AACF,CAAC;AAED,IAAI,OAAO;AACT,UAAQ,MAAM,MAAM,OAAO;AAC3B,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,cAAc;AAAA,EAClB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,IAAI,YAAY,WAAW,GAAG;AAC5B,UAAQ,MAAM,WAAW;AACzB,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAI,OAAO,MAAM;AACf,UAAQ,MAAM,WAAW;AACzB,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,CAAC,gBAAgB,cAAc,IAAI;AACzC,IAAM,EAAE,UAAU,UAAU,iBAAiB,IAAI;AAEjD,IAAI;AAEJ,IAAI,kBAAkB;AACpB,QAAM,aAAaJ,IAAG,eAAe,kBAAkBA,IAAG,IAAI,QAAQ;AACtE,QAAM,kBAAkBA,IAAG;AAAA,IACzB,WAAW;AAAA,IACXA,IAAG;AAAA,IACH;AAAA,EACF;AAEA,wBAAsB;AACxB;AAEA,IAAM,SAAS,MAAM,aAAa;AAAA,EAChC;AAAA,EACA;AAAA,EACA,UAAU;AAAA,IACR,SAAS;AAAA,EACX;AAAA,EACA,mBAAmB,qBAAqB;AAC1C,CAAC;AAED,QAAQ,IAAI,MAAM;",
  "names": ["sourceFileName", "typeExpression", "ts", "ts", "result", "error", "values", "positionals"]
}


package/dist/index.cjs

@@ -64,7 +64,12 @@ var createExpandCodeBlock = (typeExpression) => {
 
     type ${identifierPrefix}Expand<T> = T extends (...args: infer A) => infer R
       ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>
-      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;
+      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};
+
+    // Forces a union of string literal types to be expanded
+    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;
+    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)(
@@ -79,14 +84,14 @@ var formatTypeExpression = async (code, prettierOptions) => {
 // src/index.ts
 var import_node_path = __toESM(require("path"), 1);
 var import_typescript2 = __toESM(require("typescript"), 1);
-var findTypeExpanderResultNode = (node) => {
+var findResultIdentifierNode = (node) => {
   if (node.getChildCount() == 0) {
     if (!import_typescript2.default.isIdentifier(node)) {
       return void 0;
     }
     return node;
   }
-  return import_typescript2.default.forEachChild(node, findTypeExpanderResultNode);
+  return import_typescript2.default.forEachChild(node, findResultIdentifierNode);
 };
 async function expandMyType(options) {
   if (options.typeExpression.trim() === "") {
@@ -127,13 +132,13 @@ async function expandMyType(options) {
   if (!sourceFile) {
     throw new Error("Source file not found!");
   }
-  const firstIdentifier = findTypeExpanderResultNode(sourceFile);
-  if (!firstIdentifier) {
+  const resultIdentifierNode = findResultIdentifierNode(sourceFile);
+  if (!resultIdentifierNode) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(firstIdentifier),
+    typeChecker.getTypeAtLocation(resultIdentifierNode),
     void 0,
     import_typescript2.default.TypeFormatFlags.NodeBuilderFlagsMask
   );
@@ -146,4 +151,4 @@ async function expandMyType(options) {
 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 node that represents the TYPE_EXPANDER_RESULT type.\n *\n * @param node Node in which the TYPE_EXPANDER_RESULT type should be searched.\n * @returns The node that represents the TYPE_EXPANDER_RESULT type.\n */\nconst findTypeExpanderResultNode = (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, findTypeExpanderResultNode);\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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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 firstIdentifier = findTypeExpanderResultNode(sourceFile);\n  if (!firstIdentifier) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;\n};\n\nexport const createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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"]
}

+//# 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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\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 createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,wBAAe;AAkBR,IAAM,8BAA8B,CACzC,gBACA,WACA,iBACA,kCACG;AACH,QAAM,qBAAqB,kBAAAA,QAAG,mBAAmB,mBAAmB,CAAC,GAAG,IAAI;AAC5E,aAAW,OAAO,OAAO,KAAK,iCAAiC,CAAC,CAAC,GAAG;AAClE,uBAAmB,GAAG,IAAI,8BAA+B,GAAG;AAAA,EAC9D;AAEA,QAAM,mBAAmB,mBAAmB;AAE5C,qBAAmB,WAAW,CAAC,aAAa;AAC1C,UAAM,WAAW,iBAAiB,QAAQ;AAE1C,QAAI,aAAa,QAAW;AAC1B,aAAO;AAAA,IACT;AAEA,QAAI,aAAa,gBAAgB;AAC/B,aAAO;AAAA,IACT;AAEA,WAAO,GAAG,SAAS;AAAA,EAAK,QAAQ;AAAA,EAClC;AAEA,SAAO;AACT;;;AC7CA,sBAAuB;AAEvB,IAAM,mBAAmB;AAElB,IAAM,wBAAwB,CAAC,mBAA2B;AAE/D,SAAO,QAAQ,gBAAgB,YAAY,gBAAgB,UAAU,gBAAgB;AAAA,WAC5E,gBAAgB,gBAAgB,cAAc;AAAA;AAAA,WAE9C,gBAAgB;AAAA,oBACP,gBAAgB,iBAAiB,gBAAgB;AAAA,kDACnB,gBAAgB,wBAAwB,gBAAgB;AAAA;AAAA;AAAA,WAG/F,gBAAgB,oCAAoC,gBAAgB,oBAAoB,gBAAgB;AAAA,WACxG,gBAAgB;AAAA,WAChB,gBAAgB;AAC3B;AAMO,IAAM,uBAAuB,OAClC,MACA,oBACG;AACH,UACE,UAAM;AAAA,IACJ,QAAQ,gBAAgB,MAAM,IAAI;AAAA,IAClC,mBAAmB;AAAA,MACjB,QAAQ;AAAA,MACR,MAAM;AAAA,IACR;AAAA,EACF,GAEC,KAAK,EACL,UAAU,QAAQ,gBAAgB,MAAM,MAAM;AACnD;;;AFjCA,uBAAiB;AAEjB,IAAAC,qBAAe;AAQf,IAAM,2BAA2B,CAAC,SAAuC;AACvE,MAAI,KAAK,cAAc,KAAK,GAAG;AAC7B,QAAI,CAAC,mBAAAC,QAAG,aAAa,IAAI,GAAG;AAC1B,aAAO;AAAA,IACT;AAIA,WAAO;AAAA,EACT;AAEA,SAAO,mBAAAA,QAAG,aAAa,MAAM,wBAAwB;AACvD;AAgEA,eAAsB,aAAa,SAA8B;AAC/D,MAAI,QAAQ,eAAe,KAAK,MAAM,IAAI;AACxC,WAAO;AAAA,EACT;AAEA,MAAI,gBAAgB,SAAS;AAC3B,WAAO,aAAa;AAAA,MAClB,gBAAgB;AAAA,MAChB,gBAAgB,QAAQ;AAAA,MACxB,+BAA+B;AAAA,QAC7B,WAAW;AACT,iBAAO,QAAQ;AAAA,QACjB;AAAA,MACF;AAAA,MACA,mBAAmB,QAAQ;AAAA,IAC7B,CAAC;AAAA,EACH;AAEA,QAAM,yBAAyB,iBAAAC,QAAK,QAAQ,QAAQ,cAAc;AAElE,QAAM,oBAAoB,QAAQ,qBAAqB;AAAA,IACrD,QAAQ;AAAA,IAER,8BAA8B;AAAA,IAC9B,0BAA0B;AAAA,IAC1B,4BAA4B;AAAA,IAC5B,SAAS;AAAA,EACX;AAEA,QAAM,eAAe;AAAA,IACnB;AAAA,IACA,sBAAsB,QAAQ,cAAc;AAAA,IAC5C;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,QAAM,UAAU,mBAAAD,QAAG;AAAA,IACjB,CAAC,sBAAsB;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,cAAc,sBAAsB;AAC/D,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,QAAM,uBAAuB,yBAAyB,UAAU;AAChE,MAAI,CAAC,sBAAsB;AACzB,UAAM,IAAI,MAAM,gBAAgB;AAAA,EAClC;AAEA,QAAM,cAAc,QAAQ,eAAe;AAC3C,QAAM,qBAAqB,YAAY;AAAA,IACrC,YAAY,kBAAkB,oBAAoB;AAAA,IAClD;AAAA,IACA,mBAAAA,QAAG,gBAAgB;AAAA,EACrB;AAEA,MAAI,QAAQ,YAAY,QAAQ,SAAS,YAAY,OAAO;AAC1D,WAAO;AAAA,EACT;AAEA,SAAO,qBAAqB,oBAAoB,QAAQ,UAAU,OAAO;AAC3E;",
  "names": ["ts", "import_typescript", "ts", "path"]
}


package/dist/index.js

@@ -29,7 +29,12 @@ var createExpandCodeBlock = (typeExpression) => {
 
     type ${identifierPrefix}Expand<T> = T extends (...args: infer A) => infer R
       ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>
-      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;
+      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};
+
+    // Forces a union of string literal types to be expanded
+    type ${identifierPrefix}ExpandString<T extends string> = ${identifierPrefix}RemoveUnderscore<${identifierPrefix}AppendUnderscore<T>>;
+    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(
@@ -44,14 +49,14 @@ var formatTypeExpression = async (code, prettierOptions) => {
 // src/index.ts
 import path from "node:path";
 import ts2 from "typescript";
-var findTypeExpanderResultNode = (node) => {
+var findResultIdentifierNode = (node) => {
   if (node.getChildCount() == 0) {
     if (!ts2.isIdentifier(node)) {
       return void 0;
     }
     return node;
   }
-  return ts2.forEachChild(node, findTypeExpanderResultNode);
+  return ts2.forEachChild(node, findResultIdentifierNode);
 };
 async function expandMyType(options) {
   if (options.typeExpression.trim() === "") {
@@ -92,13 +97,13 @@ async function expandMyType(options) {
   if (!sourceFile) {
     throw new Error("Source file not found!");
   }
-  const firstIdentifier = findTypeExpanderResultNode(sourceFile);
-  if (!firstIdentifier) {
+  const resultIdentifierNode = findResultIdentifierNode(sourceFile);
+  if (!resultIdentifierNode) {
     throw new Error("No node found!");
   }
   const typeChecker = program.getTypeChecker();
   const expandedTypeString = typeChecker.typeToString(
-    typeChecker.getTypeAtLocation(firstIdentifier),
+    typeChecker.getTypeAtLocation(resultIdentifierNode),
     void 0,
     ts2.TypeFormatFlags.NodeBuilderFlagsMask
   );
@@ -110,4 +115,4 @@ async function expandMyType(options) {
 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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: ${identifierPrefix}Expand<T[K]>; } & {};`;\n};\n\nexport const createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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 node that represents the TYPE_EXPANDER_RESULT type.\n *\n * @param node Node in which the TYPE_EXPANDER_RESULT type should be searched.\n * @returns The node that represents the TYPE_EXPANDER_RESULT type.\n */\nconst findTypeExpanderResultNode = (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, findTypeExpanderResultNode);\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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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 firstIdentifier = findTypeExpanderResultNode(sourceFile);\n  if (!firstIdentifier) {\n    throw new Error(\"No node found!\");\n  }\n\n  const typeChecker = program.getTypeChecker();\n  const expandedTypeString = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\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"]
}

+//# 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 readFileFunction\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> = T extends (...args: infer A) => infer R\n      ? (...args: ${identifierPrefix}Expand<A>) => ${identifierPrefix}Expand<R>\n      : { [K in keyof T]: T[K] extends string ? ${identifierPrefix}ExpandString<T[K]> : ${identifierPrefix}Expand<T[K]>; } & {};\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 createSimpleTypeAlias = (typeExpression: string) => {\n  return `type ${identifierPrefix}Result = ${typeExpression};`;\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    return expandMyType({\n      sourceFileName: \"dummy.ts\",\n      typeExpression: options.typeExpression,\n      compilerHostFunctionOverrides: {\n        readFile() {\n          return options.sourceText;\n        },\n      },\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\n\n  const resolvedSourceFileName = path.resolve(options.sourceFileName);\n\n  const tsCompilerOptions = options.tsCompilerOptions ?? {\n    noEmit: true,\n\n    allowSyntheticDefaultImports: true,\n    allowArbitraryExtensions: true,\n    allowImportingTsExtensions: true,\n    allowJs: true,\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"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expand-my-type",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Expand TypeScript type expressions programmatically",
   "keywords": [
     "expand",
@@ -57,9 +57,9 @@
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^4.3.0",
     "@types/node": "^20.12.12",
-    "npm-check-updates": "^16.14.18",
-    "prettier-plugin-packagejson": "^2.4.14",
+    "npm-check-updates": "^16.14.20",
+    "prettier-plugin-packagejson": "^2.5.0",
     "tsup": "^8.0.2",
-    "tsx": "^4.10.5"
+    "tsx": "^4.11.0"
   }
 }