expand-my-type 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Fardjad Davari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# Expand My Type
+
+<div class="paragraph">
+
+<span class="image"><a href="https://www.npmjs.com/package/expand-my-type" class="image"><img src="https://img.shields.io/npm/v/expand-my-type" alt="NPM Version" /></a></span> <span class="image"><a href="https://www.npmjs.com/package/expand-my-type" class="image"><img src="https://img.shields.io/npm/dm/expand-my-type" alt="Monthly Downloads" /></a></span> <span class="image"><a href="https://github.com/fardjad/node-expand-my-type/actions" class="image"><img src="https://img.shields.io/github/actions/workflow/status/fardjad/node-expand-my-type/test-and-release.yml?branch=main" alt="test-and-release Workflow Status" /></a></span>
+
+</div>
+
+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]:
+
+```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. 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
+
+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:
+
+   ```typescript
+   interface SomeInterface {
+     a: number;
+     b?: string;
+     c: number | undefined;
+   }
+
+   type SomeType = {
+     d: number;
+     e: SomeInterface;
+     f: () => void;
+   };
+   ```
+
+   Running the following code expands the type expression `SomeType`:
+
+   ```typescript
+   import { expandMyType } from "expand-my-type";
+
+   const expandedType = await expandMyType({
+     typeExpression: "SomeType",
+     sourceFileName: "./example.ts",
+   });
+
+   console.log(expandedType);
+   /* {
+     d: number
+     e: { a: number; b?: string; c: number }
+     f: {}
+   } */
+   ```
+
+2. Expand the type expression in a source text:
+
+   ```typescript
+   import { expandMyType } from "expand-my-type";
+
+   const expandedType = await expandMyType({
+     typeExpression: "A<number>",
+     sourceText: `
+        type A<T> = {
+          a: string;
+        } & B<T>;
+    
+        type B<T> = {
+          b: T;
+        };
+      `,
+   });
+
+   console.log(expandedType);
+   /* { a: string; b: number } */
+   ```
+
+[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/index.cjs

@@ -0,0 +1,150 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  expandMyType: () => expandMyType
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/create-expander-compiler-host.ts
+var import_typescript = __toESM(require("typescript"), 1);
+var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOptions, getSourceFileFunction) => {
+  const customCompilerHost = import_typescript.default.createCompilerHost(compilerOptions ?? {});
+  const originalGetSourceFile = customCompilerHost.getSourceFile;
+  customCompilerHost.getSourceFile = (fileName, ...args) => {
+    if (fileName === sourceFileName) {
+      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(
+        fileName,
+        ...args
+      );
+      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");
+      return import_typescript.default.createSourceFile(
+        fileName,
+        sourceText,
+        sourceFile.languageVersion,
+        true
+      );
+    }
+    return originalGetSourceFile(fileName, ...args);
+  };
+  return customCompilerHost;
+};
+
+// src/index.ts
+var import_prettier = require("prettier");
+var import_typescript2 = __toESM(require("typescript"), 1);
+var findTypeExpanderResultNode = (node) => {
+  if (node.getChildCount() == 0) {
+    if (!import_typescript2.default.isIdentifier(node)) {
+      return void 0;
+    }
+    return node;
+  }
+  return import_typescript2.default.forEachChild(node, findTypeExpanderResultNode);
+};
+async function expandMyType(options) {
+  if (options.typeExpression.trim() === "") {
+    return "never";
+  }
+  if ("sourceText" in options) {
+    const sourceFile2 = import_typescript2.default.createSourceFile(
+      "test.ts",
+      options.sourceText,
+      import_typescript2.default.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 = import_typescript2.default.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,
+    import_typescript2.default.TypeFormatFlags.NodeBuilderFlagsMask
+  );
+  if (options.prettify && options.prettify.enabled === false) {
+    return expandedType;
+  }
+  const dummyTypeName = "__TYPE_EXPANDER_RESULT__";
+  return (await (0, import_prettier.format)(
+    `type ${dummyTypeName} = ${expandedType}`,
+    options.prettify?.options ?? {
+      parser: "typescript",
+      semi: false
+    }
+  )).trim().substring(`type ${dummyTypeName} = `.length);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandMyType
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/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"]
}


package/dist/index.d.cts

@@ -0,0 +1,50 @@
+import { Options } from 'prettier';
+import ts from 'typescript';
+
+type ExpandTypeOptionsBase = {
+    /**
+     * The type expression to expand.
+     * @example "ReturnType<typeof myFunction>"
+     */
+    typeExpression: string;
+    /**
+     * TypeScript compiler options.
+     */
+    tsCompilerOptions?: ts.CompilerOptions;
+    /**
+     * Prettier options.
+     */
+    prettify?: {
+        /**
+         * Whether to prettify the output.
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Prettier options. Don't forget to set the parser to "typescript".
+         * @default { parser: "typescript", semi: false }
+         */
+        options?: Options;
+    };
+};
+type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {
+    /**
+     * Name of the source file to evaluate the type expression in.
+     */
+    sourceFileName: string;
+    /**
+     * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.
+     */
+    getSourceFileFunction?: ts.CompilerHost["getSourceFile"];
+};
+type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {
+    /**
+     * TypeScript source text to evaluate the type expression in.
+     */
+    sourceText: string;
+};
+type ExpandMyTypeOptions = ExpandTypeFromSourceFileOptions | ExpandTypeFromSourceTextOptions;
+declare function expandMyType(options: ExpandTypeFromSourceTextOptions): Promise<string>;
+declare function expandMyType(options: ExpandTypeFromSourceFileOptions): Promise<string>;
+
+export { type ExpandMyTypeOptions, type ExpandTypeFromSourceFileOptions, type ExpandTypeFromSourceTextOptions, type ExpandTypeOptionsBase, expandMyType };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { Options } from 'prettier';
+import ts from 'typescript';
+
+type ExpandTypeOptionsBase = {
+    /**
+     * The type expression to expand.
+     * @example "ReturnType<typeof myFunction>"
+     */
+    typeExpression: string;
+    /**
+     * TypeScript compiler options.
+     */
+    tsCompilerOptions?: ts.CompilerOptions;
+    /**
+     * Prettier options.
+     */
+    prettify?: {
+        /**
+         * Whether to prettify the output.
+         * @default true
+         */
+        enabled?: boolean;
+        /**
+         * Prettier options. Don't forget to set the parser to "typescript".
+         * @default { parser: "typescript", semi: false }
+         */
+        options?: Options;
+    };
+};
+type ExpandTypeFromSourceFileOptions = ExpandTypeOptionsBase & {
+    /**
+     * Name of the source file to evaluate the type expression in.
+     */
+    sourceFileName: string;
+    /**
+     * Function that returns the source file. When not specified, the implementation of the default TypeScript compiler host is used.
+     */
+    getSourceFileFunction?: ts.CompilerHost["getSourceFile"];
+};
+type ExpandTypeFromSourceTextOptions = ExpandTypeOptionsBase & {
+    /**
+     * TypeScript source text to evaluate the type expression in.
+     */
+    sourceText: string;
+};
+type ExpandMyTypeOptions = ExpandTypeFromSourceFileOptions | ExpandTypeFromSourceTextOptions;
+declare function expandMyType(options: ExpandTypeFromSourceTextOptions): Promise<string>;
+declare function expandMyType(options: ExpandTypeFromSourceFileOptions): Promise<string>;
+
+export { type ExpandMyTypeOptions, type ExpandTypeFromSourceFileOptions, type ExpandTypeFromSourceTextOptions, type ExpandTypeOptionsBase, expandMyType };

package/dist/index.js

@@ -0,0 +1,114 @@
+// src/create-expander-compiler-host.ts
+import ts from "typescript";
+var createExpanderCompilerHost = (sourceFileName, typeExpression, compilerOptions, getSourceFileFunction) => {
+  const customCompilerHost = ts.createCompilerHost(compilerOptions ?? {});
+  const originalGetSourceFile = customCompilerHost.getSourceFile;
+  customCompilerHost.getSourceFile = (fileName, ...args) => {
+    if (fileName === sourceFileName) {
+      const sourceFile = (getSourceFileFunction ?? originalGetSourceFile)(
+        fileName,
+        ...args
+      );
+      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");
+      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);
+}
+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"]
}


package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "expand-my-type",
+  "version": "0.1.0",
+  "description": "Expand TypeScript type expressions programmatically",
+  "keywords": [
+    "expand",
+    "typescript",
+    "types"
+  ],
+  "homepage": "https://github.com/fardjad/node-expand-my-type",
+  "bugs": {
+    "url": "https://github.com/fardjad/node-expand-my-type/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/fardjad/node-expand-my-type.git"
+  },
+  "license": "MIT",
+  "author": "Fardjad Davari <public@fardjad.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "default": "./dist/index.cjs",
+        "types": "./dist/index.d.cts"
+      },
+      "import": {
+        "default": "./dist/index.js",
+        "types": "./dist/index.d.ts"
+      }
+    }
+  },
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/index.cjs",
+    "dist/index.d.cts",
+    "dist/index.d.ts",
+    "dist/index.js"
+  ],
+  "scripts": {
+    "format": "prettier --write .",
+    "prepare": "tsup ./src/index.ts --format esm,cjs --dts --clean --sourcemap inline --silent",
+    "pretest": "tsc",
+    "test": "tsx --test --test-reporter spec ./src/index.test.ts"
+  },
+  "dependencies": {
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.5"
+  },
+  "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",
+    "tsup": "^8.0.2",
+    "tsx": "^4.10.5"
+  }
+}