expand-my-type 0.1.0 → 0.3.0

package/README.md

@@ -23,23 +23,76 @@ 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. 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 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.
 
 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].
 
-# Usage
+# CLI
+
+### Installation
+
+To install the CLI globally, run:
+
+```sh
+npm install -g expand-my-type
+```
+
+Alternatively, the CLI can be run using `npx`:
+
+```sh
+npx expand-my-type
+```
+
+### CLI Usage
+
+```
+Usage:
+  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
+```
+
+Given a file named `example.ts` with the following contents:
+
+```typescript
+interface SomeInterface {
+  a: number;
+  b?: string;
+  c: number | undefined;
+}
+
+type SomeType = {
+  d: number;
+  e: SomeInterface;
+  f: () => void;
+};
+```
+
+Running the following command expands the type expression `SomeType["e"]`:
+
+```sh
+expand-my-type example.ts 'SomeType["e"]'
+# Output:
+# { a: number; b?: string; c: number }
+```
+
+# API
 
 This package exports a function named `expandMyType` that can be used in one of
 the following ways:
 
 1. Expand the type expression in a source file:
 
-   Given a file named `example.ts` with the following content:
+   Given a file named `example.ts` with the following contents:
 
    ```typescript
    interface SomeInterface {
@@ -69,7 +122,7 @@ the following ways:
    /* {
      d: number
      e: { a: number; b?: string; c: number }
-     f: {}
+     f: () => void
    } */
    ```
 
@@ -95,6 +148,39 @@ the following ways:
    /* { a: string; b: number } */
    ```
 
+# Limitations
+
+Expand My Type uses the following utility type to expand the type expression:
+
+```typescript
+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. That
+comes with some limitations. If you know a better approach to expand types, feel
+free to open an issue or a pull request.
+
+## Type References to Union String Literal Types
+
+Type references to union string literal types are not expanded. For example,
+expanding T in the following code:
+
+```typescript
+type T = { s: S };
+type S = "a" | "b";
+```
+
+results in `{ s: S }` instead of `{ s: "a" | "b" }`.
+
+## Recursive Type References
+
+Expanding recursive type references can lead to infinite loops. When an infinite
+loop happens, the generated output gets truncated. Prettifying the truncated
+output will throw an error.
+
 [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

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+// src/create-expander-compiler-host.ts
+import ts from "typescript";
+var identifierPrefix = "__TYPE_EXPANDER__";
+var createExpanderCompilerHost = (sourceFileName2, typeExpression2, compilerOptions, getSourceFileFunction) => {
+  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});
+  const originalGetSourceFile = customCompilerHost.getSourceFile;
+  customCompilerHost.getSourceFile = (fileName, ...args) => {
+    if (fileName === sourceFileName2) {
+      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(
+        fileName,
+        ...args
+      );
+      if (sourceFile === void 0) {
+        return void 0;
+      }
+      const sourceText = `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
+        type ${identifierPrefix}Expression = ${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]>; } & {};
+          
+        ${sourceFile.getFullText()}`;
+      return ts.createSourceFile(
+        fileName,
+        sourceText,
+        sourceFile.languageVersion,
+        true
+      );
+    }
+    return originalGetSourceFile(fileName, ...args);
+  };
+  return customCompilerHost;
+};
+
+// src/index.ts
+import { format } from "prettier";
+import ts2 from "typescript";
+var findTypeExpanderResultNode = (node) => {
+  if (node.getChildCount() == 0) {
+    if (!ts2.isIdentifier(node)) {
+      return void 0;
+    }
+    return node;
+  }
+  return ts2.forEachChild(node, findTypeExpanderResultNode);
+};
+async function expandMyType(options) {
+  if (options.typeExpression.trim() === "") {
+    return "never";
+  }
+  if ("sourceText" in options) {
+    const sourceFile2 = ts2.createSourceFile(
+      "test.ts",
+      options.sourceText,
+      ts2.ScriptTarget.Latest,
+      true
+    );
+    return expandMyType({
+      sourceFileName: "test.ts",
+      typeExpression: options.typeExpression,
+      getSourceFileFunction: () => sourceFile2,
+      tsCompilerOptions: options.tsCompilerOptions
+    });
+  }
+  const tsCompilerOptions = options.tsCompilerOptions ?? {
+    noEmit: true,
+    allowSyntheticDefaultImports: true,
+    allowArbitraryExtensions: true,
+    allowImportingTsExtensions: true,
+    allowJs: true
+  };
+  const compilerHost = createExpanderCompilerHost(
+    options.sourceFileName,
+    options.typeExpression,
+    tsCompilerOptions,
+    options.getSourceFileFunction
+  );
+  const program = ts2.createProgram(
+    [options.sourceFileName],
+    tsCompilerOptions,
+    compilerHost
+  );
+  const sourceFile = program.getSourceFile(options.sourceFileName);
+  if (!sourceFile) {
+    throw new Error("Source file not found!");
+  }
+  const firstIdentifier = findTypeExpanderResultNode(sourceFile);
+  if (!firstIdentifier) {
+    throw new Error("No node found!");
+  }
+  const typeChecker = program.getTypeChecker();
+  const expandedType = typeChecker.typeToString(
+    typeChecker.getTypeAtLocation(firstIdentifier),
+    void 0,
+    ts2.TypeFormatFlags.NodeBuilderFlagsMask
+  );
+  if (options.prettify && options.prettify.enabled === false) {
+    return expandedType;
+  }
+  const dummyTypeName = "__TYPE_EXPANDER_RESULT__";
+  return (await format(
+    `type ${dummyTypeName} = ${expandedType}`,
+    options.prettify?.options ?? {
+      parser: "typescript",
+      semi: false
+    }
+  )).trim().substring(`type ${dummyTypeName} = `.length);
+}
+
+// src/cli.ts
+import path from "node:path";
+import { parseArgs } from "node:util";
+import ts3 from "typescript";
+var tryParse = (options) => {
+  let result2;
+  try {
+    result2 = parseArgs({
+      options,
+      tokens: true,
+      allowPositionals: true
+    });
+  } catch (error2) {
+    return {
+      error: error2,
+      values: {},
+      positionals: []
+    };
+  }
+  const { tokens, values: values2, positionals: positionals2 } = result2;
+  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];
+    } else {
+      values2[token.name] = token.value ?? true;
+    }
+  }
+  return {
+    error: void 0,
+    values: values2,
+    positionals: positionals2
+  };
+};
+var { error, values, positionals } = tryParse({
+  help: {
+    type: "boolean",
+    short: "h"
+  },
+  prettify: {
+    type: "boolean",
+    short: "p",
+    default: true
+  },
+  "no-prettify": {
+    type: "boolean",
+    short: "P"
+  },
+  tsconfig: {
+    type: "string",
+    short: "c"
+  }
+});
+if (error) {
+  console.error(error.message);
+  process.exit(1);
+}
+var usagePrompt = [
+  "Usage:",
+  "  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);
+}
+if (values.help) {
+  console.error(usagePrompt);
+  process.exit(0);
+}
+var [sourceFileName, typeExpression] = positionals;
+var { prettify, tsconfig: tsConfigFileName } = values;
+var tsParsedCommandLine;
+if (tsConfigFileName) {
+  const configFile = ts3.readConfigFile(tsConfigFileName, ts3.sys.readFile);
+  const compilerOptions = ts3.parseJsonConfigFileContent(
+    configFile.config,
+    ts3.sys,
+    "./"
+  );
+  tsParsedCommandLine = compilerOptions;
+}
+var result = await expandMyType({
+  sourceFileName: path.resolve(sourceFileName),
+  typeExpression,
+  prettify: {
+    enabled: prettify
+  },
+  tsCompilerOptions: tsParsedCommandLine?.options
+});
+console.log(result);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/create-expander-compiler-host.ts", "../src/index.ts", "../src/cli.ts"],
  "sourcesContent": ["import ts from \"typescript\";\n\nconst identifierPrefix = \"__TYPE_EXPANDER__\";\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 typeExpression Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param getSourceFileFunction The implementation of the `ts.CompilerHost[\"getSourceFile\"]` function.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createExpanderCompilerHost = (\n  sourceFileName: string,\n  typeExpression: string,\n  compilerOptions?: ts.CompilerOptions,\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"],\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});\n  const originalGetSourceFile = customCompilerHost.getSourceFile;\n\n  customCompilerHost.getSourceFile = (fileName, ...args) => {\n    if (fileName === sourceFileName) {\n      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(\n        fileName,\n        ...args,\n      );\n\n      if (sourceFile === undefined) {\n        return undefined;\n      }\n\n      // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n      const sourceText = `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        ${sourceFile.getFullText()}`;\n\n      return ts.createSourceFile(\n        fileName,\n        sourceText,\n        sourceFile.languageVersion,\n        true,\n      );\n    }\n\n    return originalGetSourceFile(fileName, ...args);\n  };\n\n  return customCompilerHost;\n};\n", "import { createExpanderCompilerHost } from \"./create-expander-compiler-host.ts\";\nimport { format, 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 __TYPE_EXPANDER_RESULT__ 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};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n  /**\n   * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.\n   */\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"];\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 sourceFile = ts.createSourceFile(\n      \"test.ts\",\n      options.sourceText,\n      ts.ScriptTarget.Latest,\n      true,\n    );\n\n    return expandMyType({\n      sourceFileName: \"test.ts\",\n      typeExpression: options.typeExpression,\n      getSourceFileFunction: () => sourceFile,\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\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 = createExpanderCompilerHost(\n    options.sourceFileName,\n    options.typeExpression,\n    tsCompilerOptions,\n    options.getSourceFileFunction,\n  );\n\n  const program = ts.createProgram(\n    [options.sourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(options.sourceFileName);\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 expandedType = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedType;\n  }\n\n  const dummyTypeName = \"__TYPE_EXPANDER_RESULT__\";\n\n  return (\n    await format(\n      `type ${dummyTypeName} = ${expandedType}`,\n      options.prettify?.options ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${dummyTypeName} = `.length);\n}\n", "#!/usr/bin/env node\nimport { expandMyType } from \"./index.ts\";\nimport path from \"node:path\";\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: path.resolve(sourceFileName),\n  typeExpression,\n  prettify: {\n    enabled: prettify,\n  },\n  tsCompilerOptions: tsParsedCommandLine?.options,\n});\n\nconsole.log(result);\n"],
  "mappings": ";;;AAAA,OAAO,QAAQ;AAEf,IAAM,mBAAmB;AAWlB,IAAM,6BAA6B,CACxCA,iBACAC,iBACA,iBACA,0BACG;AACH,QAAM,qBAAqB,GAAG,mBAAmB,mBAAmB,CAAC,CAAC;AACtE,QAAM,wBAAwB,mBAAmB;AAEjD,qBAAmB,gBAAgB,CAAC,aAAa,SAAS;AACxD,QAAI,aAAaD,iBAAgB;AAC/B,YAAM,cAAc,yBAAyB;AAAA,QAC3C;AAAA,QACA,GAAG;AAAA,MACL;AAEA,UAAI,eAAe,QAAW;AAC5B,eAAO;AAAA,MACT;AAGA,YAAM,aAAa,QAAQ,gBAAgB,YAAY,gBAAgB,UAAU,gBAAgB;AAAA,eACxF,gBAAgB,gBAAgBC,eAAc;AAAA;AAAA,eAE9C,gBAAgB;AAAA,wBACP,gBAAgB,iBAAiB,gBAAgB;AAAA,gCACzC,gBAAgB;AAAA;AAAA,UAEtC,WAAW,YAAY,CAAC;AAE5B,aAAO,GAAG;AAAA,QACR;AAAA,QACA;AAAA,QACA,WAAW;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAEA,WAAO,sBAAsB,UAAU,GAAG,IAAI;AAAA,EAChD;AAEA,SAAO;AACT;;;ACtDA,SAAS,cAA+C;AACxD,OAAOC,SAAQ;AAQf,IAAM,6BAA6B,CAAC,SAAuC;AACzE,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,0BAA0B;AACzD;AA+DA,eAAsB,aAAa,SAA8B;AAC/D,MAAI,QAAQ,eAAe,KAAK,MAAM,IAAI;AACxC,WAAO;AAAA,EACT;AAEA,MAAI,gBAAgB,SAAS;AAC3B,UAAMC,cAAaD,IAAG;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACRA,IAAG,aAAa;AAAA,MAChB;AAAA,IACF;AAEA,WAAO,aAAa;AAAA,MAClB,gBAAgB;AAAA,MAChB,gBAAgB,QAAQ;AAAA,MACxB,uBAAuB,MAAMC;AAAA,MAC7B,mBAAmB,QAAQ;AAAA,IAC7B,CAAC;AAAA,EACH;AAEA,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,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,QAAM,UAAUD,IAAG;AAAA,IACjB,CAAC,QAAQ,cAAc;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,cAAc,QAAQ,cAAc;AAC/D,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,QAAM,kBAAkB,2BAA2B,UAAU;AAC7D,MAAI,CAAC,iBAAiB;AACpB,UAAM,IAAI,MAAM,gBAAgB;AAAA,EAClC;AAEA,QAAM,cAAc,QAAQ,eAAe;AAC3C,QAAM,eAAe,YAAY;AAAA,IAC/B,YAAY,kBAAkB,eAAe;AAAA,IAC7C;AAAA,IACAA,IAAG,gBAAgB;AAAA,EACrB;AAEA,MAAI,QAAQ,YAAY,QAAQ,SAAS,YAAY,OAAO;AAC1D,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,UACE,MAAM;AAAA,IACJ,QAAQ,aAAa,MAAM,YAAY;AAAA,IACvC,QAAQ,UAAU,WAAW;AAAA,MAC3B,QAAQ;AAAA,MACR,MAAM;AAAA,IACR;AAAA,EACF,GAEC,KAAK,EACL,UAAU,QAAQ,aAAa,MAAM,MAAM;AAChD;;;AChKA,OAAO,UAAU;AACjB,SAAS,iBAAuC;AAChD,OAAOE,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,gBAAgB,KAAK,QAAQ,cAAc;AAAA,EAC3C;AAAA,EACA,UAAU;AAAA,IACR,SAAS;AAAA,EACX;AAAA,EACA,mBAAmB,qBAAqB;AAC1C,CAAC;AAED,QAAQ,IAAI,MAAM;",
  "names": ["sourceFileName", "typeExpression", "ts", "sourceFile", "ts", "result", "error", "values", "positionals"]
}


package/dist/index.cjs

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/create-expander-compiler-host.ts
 var import_typescript = __toESM(require("typescript"), 1);
+var identifierPrefix = "__TYPE_EXPANDER__";
 var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOptions, getSourceFileFunction) => {
   const customCompilerHost = import_typescript.default.createCompilerHost(compilerOptions ?? {});
   const originalGetSourceFile = customCompilerHost.getSourceFile;
@@ -47,16 +48,14 @@ var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOption
       if (sourceFile === void 0) {
         return void 0;
       }
-      const sourceText = [
-        ...[
-          "type __TYPE_EXPANDER_RESULT__ = __TYPE_EXPANDER_EXPAND__<__TYPE_EXPANDER_EXPRESSION__>;",
-          `type __TYPE_EXPANDER_EXPRESSION__ = ${typeExpression};`,
-          "type __TYPE_EXPANDER_EXPAND__<T> = {",
-          "  [K in keyof T]: __TYPE_EXPANDER_EXPAND__<T[K]>;",
-          "} & {};"
-        ],
-        sourceFile.getFullText()
-      ].join("\n");
+      const sourceText = `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
+        type ${identifierPrefix}Expression = ${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]>; } & {};
+          
+        ${sourceFile.getFullText()}`;
       return import_typescript.default.createSourceFile(
         fileName,
         sourceText,
@@ -147,4 +146,4 @@ async function expandMyType(options) {
 0 && (module.exports = {
   expandMyType
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/create-expander-compiler-host.ts"],
  "sourcesContent": ["import { createExpanderCompilerHost } from \"./create-expander-compiler-host.ts\";\nimport { format, 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 __TYPE_EXPANDER_RESULT__ 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};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n  /**\n   * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.\n   */\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"];\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 sourceFile = ts.createSourceFile(\n      \"test.ts\",\n      options.sourceText,\n      ts.ScriptTarget.Latest,\n      true,\n    );\n\n    return expandMyType({\n      sourceFileName: \"test.ts\",\n      typeExpression: options.typeExpression,\n      getSourceFileFunction: () => sourceFile,\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\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 = createExpanderCompilerHost(\n    options.sourceFileName,\n    options.typeExpression,\n    tsCompilerOptions,\n    options.getSourceFileFunction,\n  );\n\n  const program = ts.createProgram(\n    [options.sourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(options.sourceFileName);\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 expandedType = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedType;\n  }\n\n  const dummyTypeName = \"__TYPE_EXPANDER_RESULT__\";\n\n  return (\n    await format(\n      `type ${dummyTypeName} = ${expandedType}`,\n      options.prettify?.options ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${dummyTypeName} = `.length);\n}\n", "import ts from \"typescript\";\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 typeExpression Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param getSourceFileFunction The implementation of the `ts.CompilerHost[\"getSourceFile\"]` function.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createExpanderCompilerHost = (\n  sourceFileName: string,\n  typeExpression: string,\n  compilerOptions?: ts.CompilerOptions,\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"],\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});\n  const originalGetSourceFile = customCompilerHost.getSourceFile;\n\n  customCompilerHost.getSourceFile = (fileName, ...args) => {\n    if (fileName === sourceFileName) {\n      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(\n        fileName,\n        ...args,\n      );\n\n      if (sourceFile === undefined) {\n        return undefined;\n      }\n\n      const sourceText = [\n        ...[\n          \"type __TYPE_EXPANDER_RESULT__ = __TYPE_EXPANDER_EXPAND__<__TYPE_EXPANDER_EXPRESSION__>;\",\n          `type __TYPE_EXPANDER_EXPRESSION__ = ${typeExpression};`,\n          \"type __TYPE_EXPANDER_EXPAND__<T> = {\",\n          \"  [K in keyof T]: __TYPE_EXPANDER_EXPAND__<T[K]>;\",\n          \"} & {};\",\n        ],\n        sourceFile.getFullText(),\n      ].join(\"\\n\");\n\n      return ts.createSourceFile(\n        fileName,\n        sourceText,\n        sourceFile.languageVersion,\n        true,\n      );\n    }\n\n    return originalGetSourceFile(fileName, ...args);\n  };\n\n  return customCompilerHost;\n};\n"],
  "mappings": "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",
  "names": ["ts", "import_typescript", "ts", "sourceFile"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/create-expander-compiler-host.ts"],
  "sourcesContent": ["import { createExpanderCompilerHost } from \"./create-expander-compiler-host.ts\";\nimport { format, 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 __TYPE_EXPANDER_RESULT__ 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};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n  /**\n   * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.\n   */\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"];\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 sourceFile = ts.createSourceFile(\n      \"test.ts\",\n      options.sourceText,\n      ts.ScriptTarget.Latest,\n      true,\n    );\n\n    return expandMyType({\n      sourceFileName: \"test.ts\",\n      typeExpression: options.typeExpression,\n      getSourceFileFunction: () => sourceFile,\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\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 = createExpanderCompilerHost(\n    options.sourceFileName,\n    options.typeExpression,\n    tsCompilerOptions,\n    options.getSourceFileFunction,\n  );\n\n  const program = ts.createProgram(\n    [options.sourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(options.sourceFileName);\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 expandedType = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedType;\n  }\n\n  const dummyTypeName = \"__TYPE_EXPANDER_RESULT__\";\n\n  return (\n    await format(\n      `type ${dummyTypeName} = ${expandedType}`,\n      options.prettify?.options ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${dummyTypeName} = `.length);\n}\n", "import ts from \"typescript\";\n\nconst identifierPrefix = \"__TYPE_EXPANDER__\";\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 typeExpression Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param getSourceFileFunction The implementation of the `ts.CompilerHost[\"getSourceFile\"]` function.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createExpanderCompilerHost = (\n  sourceFileName: string,\n  typeExpression: string,\n  compilerOptions?: ts.CompilerOptions,\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"],\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});\n  const originalGetSourceFile = customCompilerHost.getSourceFile;\n\n  customCompilerHost.getSourceFile = (fileName, ...args) => {\n    if (fileName === sourceFileName) {\n      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(\n        fileName,\n        ...args,\n      );\n\n      if (sourceFile === undefined) {\n        return undefined;\n      }\n\n      // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n      const sourceText = `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        ${sourceFile.getFullText()}`;\n\n      return ts.createSourceFile(\n        fileName,\n        sourceText,\n        sourceFile.languageVersion,\n        true,\n      );\n    }\n\n    return originalGetSourceFile(fileName, ...args);\n  };\n\n  return customCompilerHost;\n};\n"],
  "mappings": "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",
  "names": ["ts", "import_typescript", "ts", "sourceFile"]
}


package/dist/index.js

@@ -1,5 +1,6 @@
 // src/create-expander-compiler-host.ts
 import ts from "typescript";
+var identifierPrefix = "__TYPE_EXPANDER__";
 var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOptions, getSourceFileFunction) => {
   const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});
   const originalGetSourceFile = customCompilerHost.getSourceFile;
@@ -12,16 +13,14 @@ var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOption
       if (sourceFile === void 0) {
         return void 0;
       }
-      const sourceText = [
-        ...[
-          "type __TYPE_EXPANDER_RESULT__ = __TYPE_EXPANDER_EXPAND__<__TYPE_EXPANDER_EXPRESSION__>;",
-          `type __TYPE_EXPANDER_EXPRESSION__ = ${typeExpression};`,
-          "type __TYPE_EXPANDER_EXPAND__<T> = {",
-          "  [K in keyof T]: __TYPE_EXPANDER_EXPAND__<T[K]>;",
-          "} & {};"
-        ],
-        sourceFile.getFullText()
-      ].join("\n");
+      const sourceText = `type ${identifierPrefix}Result = ${identifierPrefix}Expand<${identifierPrefix}Expression>;
+        type ${identifierPrefix}Expression = ${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]>; } & {};
+          
+        ${sourceFile.getFullText()}`;
       return ts.createSourceFile(
         fileName,
         sourceText,
@@ -111,4 +110,4 @@ async function expandMyType(options) {
 export {
   expandMyType
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/create-expander-compiler-host.ts", "../src/index.ts"],
  "sourcesContent": ["import ts from \"typescript\";\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 typeExpression Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param getSourceFileFunction The implementation of the `ts.CompilerHost[\"getSourceFile\"]` function.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createExpanderCompilerHost = (\n  sourceFileName: string,\n  typeExpression: string,\n  compilerOptions?: ts.CompilerOptions,\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"],\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});\n  const originalGetSourceFile = customCompilerHost.getSourceFile;\n\n  customCompilerHost.getSourceFile = (fileName, ...args) => {\n    if (fileName === sourceFileName) {\n      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(\n        fileName,\n        ...args,\n      );\n\n      if (sourceFile === undefined) {\n        return undefined;\n      }\n\n      const sourceText = [\n        ...[\n          \"type __TYPE_EXPANDER_RESULT__ = __TYPE_EXPANDER_EXPAND__<__TYPE_EXPANDER_EXPRESSION__>;\",\n          `type __TYPE_EXPANDER_EXPRESSION__ = ${typeExpression};`,\n          \"type __TYPE_EXPANDER_EXPAND__<T> = {\",\n          \"  [K in keyof T]: __TYPE_EXPANDER_EXPAND__<T[K]>;\",\n          \"} & {};\",\n        ],\n        sourceFile.getFullText(),\n      ].join(\"\\n\");\n\n      return ts.createSourceFile(\n        fileName,\n        sourceText,\n        sourceFile.languageVersion,\n        true,\n      );\n    }\n\n    return originalGetSourceFile(fileName, ...args);\n  };\n\n  return customCompilerHost;\n};\n", "import { createExpanderCompilerHost } from \"./create-expander-compiler-host.ts\";\nimport { format, 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 __TYPE_EXPANDER_RESULT__ 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};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n  /**\n   * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.\n   */\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"];\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 sourceFile = ts.createSourceFile(\n      \"test.ts\",\n      options.sourceText,\n      ts.ScriptTarget.Latest,\n      true,\n    );\n\n    return expandMyType({\n      sourceFileName: \"test.ts\",\n      typeExpression: options.typeExpression,\n      getSourceFileFunction: () => sourceFile,\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\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 = createExpanderCompilerHost(\n    options.sourceFileName,\n    options.typeExpression,\n    tsCompilerOptions,\n    options.getSourceFileFunction,\n  );\n\n  const program = ts.createProgram(\n    [options.sourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(options.sourceFileName);\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 expandedType = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedType;\n  }\n\n  const dummyTypeName = \"__TYPE_EXPANDER_RESULT__\";\n\n  return (\n    await format(\n      `type ${dummyTypeName} = ${expandedType}`,\n      options.prettify?.options ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${dummyTypeName} = `.length);\n}\n"],
  "mappings": ";AAAA,OAAO,QAAQ;AAWR,IAAM,6BAA6B,CACxC,gBACA,gBACA,iBACA,0BACG;AACH,QAAM,qBAAqB,GAAG,mBAAmB,mBAAmB,CAAC,CAAC;AACtE,QAAM,wBAAwB,mBAAmB;AAEjD,qBAAmB,gBAAgB,CAAC,aAAa,SAAS;AACxD,QAAI,aAAa,gBAAgB;AAC/B,YAAM,cAAc,yBAAyB;AAAA,QAC3C;AAAA,QACA,GAAG;AAAA,MACL;AAEA,UAAI,eAAe,QAAW;AAC5B,eAAO;AAAA,MACT;AAEA,YAAM,aAAa;AAAA,QACjB,GAAG;AAAA,UACD;AAAA,UACA,uCAAuC,cAAc;AAAA,UACrD;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,QACA,WAAW,YAAY;AAAA,MACzB,EAAE,KAAK,IAAI;AAEX,aAAO,GAAG;AAAA,QACR;AAAA,QACA;AAAA,QACA,WAAW;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAEA,WAAO,sBAAsB,UAAU,GAAG,IAAI;AAAA,EAChD;AAEA,SAAO;AACT;;;ACrDA,SAAS,cAA+C;AACxD,OAAOA,SAAQ;AAQf,IAAM,6BAA6B,CAAC,SAAuC;AACzE,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,0BAA0B;AACzD;AA+DA,eAAsB,aAAa,SAA8B;AAC/D,MAAI,QAAQ,eAAe,KAAK,MAAM,IAAI;AACxC,WAAO;AAAA,EACT;AAEA,MAAI,gBAAgB,SAAS;AAC3B,UAAMC,cAAaD,IAAG;AAAA,MACpB;AAAA,MACA,QAAQ;AAAA,MACRA,IAAG,aAAa;AAAA,MAChB;AAAA,IACF;AAEA,WAAO,aAAa;AAAA,MAClB,gBAAgB;AAAA,MAChB,gBAAgB,QAAQ;AAAA,MACxB,uBAAuB,MAAMC;AAAA,MAC7B,mBAAmB,QAAQ;AAAA,IAC7B,CAAC;AAAA,EACH;AAEA,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,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR;AAAA,IACA,QAAQ;AAAA,EACV;AAEA,QAAM,UAAUD,IAAG;AAAA,IACjB,CAAC,QAAQ,cAAc;AAAA,IACvB;AAAA,IACA;AAAA,EACF;AAEA,QAAM,aAAa,QAAQ,cAAc,QAAQ,cAAc;AAC/D,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAEA,QAAM,kBAAkB,2BAA2B,UAAU;AAC7D,MAAI,CAAC,iBAAiB;AACpB,UAAM,IAAI,MAAM,gBAAgB;AAAA,EAClC;AAEA,QAAM,cAAc,QAAQ,eAAe;AAC3C,QAAM,eAAe,YAAY;AAAA,IAC/B,YAAY,kBAAkB,eAAe;AAAA,IAC7C;AAAA,IACAA,IAAG,gBAAgB;AAAA,EACrB;AAEA,MAAI,QAAQ,YAAY,QAAQ,SAAS,YAAY,OAAO;AAC1D,WAAO;AAAA,EACT;AAEA,QAAM,gBAAgB;AAEtB,UACE,MAAM;AAAA,IACJ,QAAQ,aAAa,MAAM,YAAY;AAAA,IACvC,QAAQ,UAAU,WAAW;AAAA,MAC3B,QAAQ;AAAA,MACR,MAAM;AAAA,IACR;AAAA,EACF,GAEC,KAAK,EACL,UAAU,QAAQ,aAAa,MAAM,MAAM;AAChD;",
  "names": ["ts", "sourceFile"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/create-expander-compiler-host.ts", "../src/index.ts"],
  "sourcesContent": ["import ts from \"typescript\";\n\nconst identifierPrefix = \"__TYPE_EXPANDER__\";\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 typeExpression Type expression.\n * @param compilerOptions TypeScript compiler options.\n * @param getSourceFileFunction The implementation of the `ts.CompilerHost[\"getSourceFile\"]` function.\n * @returns A custom compiler host that returns an augmented source file that can be used to expand the type expression.\n */\nexport const createExpanderCompilerHost = (\n  sourceFileName: string,\n  typeExpression: string,\n  compilerOptions?: ts.CompilerOptions,\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"],\n) => {\n  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});\n  const originalGetSourceFile = customCompilerHost.getSourceFile;\n\n  customCompilerHost.getSourceFile = (fileName, ...args) => {\n    if (fileName === sourceFileName) {\n      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(\n        fileName,\n        ...args,\n      );\n\n      if (sourceFile === undefined) {\n        return undefined;\n      }\n\n      // https://github.com/microsoft/TypeScript/blob/main/tests/cases/compiler/computedTypesKeyofNoIndexSignatureType.ts\n      const sourceText = `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        ${sourceFile.getFullText()}`;\n\n      return ts.createSourceFile(\n        fileName,\n        sourceText,\n        sourceFile.languageVersion,\n        true,\n      );\n    }\n\n    return originalGetSourceFile(fileName, ...args);\n  };\n\n  return customCompilerHost;\n};\n", "import { createExpanderCompilerHost } from \"./create-expander-compiler-host.ts\";\nimport { format, 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 __TYPE_EXPANDER_RESULT__ 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};\nexport type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {\n  /**\n   * Name of the source file to evaluate the type expression in.\n   */\n  sourceFileName: string;\n  /**\n   * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.\n   */\n  getSourceFileFunction?: ts.CompilerHost[\"getSourceFile\"];\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 sourceFile = ts.createSourceFile(\n      \"test.ts\",\n      options.sourceText,\n      ts.ScriptTarget.Latest,\n      true,\n    );\n\n    return expandMyType({\n      sourceFileName: \"test.ts\",\n      typeExpression: options.typeExpression,\n      getSourceFileFunction: () => sourceFile,\n      tsCompilerOptions: options.tsCompilerOptions,\n    });\n  }\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 = createExpanderCompilerHost(\n    options.sourceFileName,\n    options.typeExpression,\n    tsCompilerOptions,\n    options.getSourceFileFunction,\n  );\n\n  const program = ts.createProgram(\n    [options.sourceFileName],\n    tsCompilerOptions,\n    compilerHost,\n  );\n\n  const sourceFile = program.getSourceFile(options.sourceFileName);\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 expandedType = typeChecker.typeToString(\n    typeChecker.getTypeAtLocation(firstIdentifier),\n    undefined,\n    ts.TypeFormatFlags.NodeBuilderFlagsMask,\n  );\n\n  if (options.prettify && options.prettify.enabled === false) {\n    return expandedType;\n  }\n\n  const dummyTypeName = \"__TYPE_EXPANDER_RESULT__\";\n\n  return (\n    await format(\n      `type ${dummyTypeName} = ${expandedType}`,\n      options.prettify?.options ?? {\n        parser: \"typescript\",\n        semi: false,\n      },\n    )\n  )\n    .trim()\n    .substring(`type ${dummyTypeName} = `.length);\n}\n"],
  "mappings": "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",
  "names": ["ts", "sourceFile"]
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expand-my-type",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Expand TypeScript type expressions programmatically",
   "keywords": [
     "expand",
@@ -32,15 +32,21 @@
   },
   "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
+  "bin": {
+    "expand-my-type": "./dist/cli.js"
+  },
   "files": [
     "dist/index.cjs",
     "dist/index.d.cts",
     "dist/index.d.ts",
-    "dist/index.js"
+    "dist/index.js",
+    "dist/cli.js"
   ],
   "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": "tsup ./src/index.ts --format esm,cjs --dts --clean --sourcemap inline --silent",
+    "prepare": "npm run bundle-lib && npm run bundle-cli",
     "pretest": "tsc",
     "test": "tsx --test --test-reporter spec ./src/index.test.ts"
   },