I have multiple types that form a larger, complex type that currently is used on my server. Is it possible to print the larger, complex type into console / file?
Example
type TypeA = {
prop1: string;
prop2: number;
}
type TypeB = Omit<TypeA, "prop2">;
console.logType(TypeB);
// {
// prop1: string;
// }
In order to extract the type signature, you'll need to use the compiler API. Assuming you have a file:
// ./src/my-file.ts
type TypeA = {
prop1: string;
prop2: number;
}
type TypeB = Omit<TypeA, "prop2">;
from a script outside your project root:
// ./type-printer.ts
import * as ts from "typescript";
function extractTypeSignature(filename: string, aliasName: string): string {
const program: ts.Program = ts.createProgram([ filename ], { emitDeclarationOnly: true });
const sourceFile: ts.SourceFile = program.getSourceFile(filename);
const typeChecker: ts.TypeChecker = program.getTypeChecker();
// Get the declaration node you're looking for by it's type name.
// This condition can be adjusted to your needs
const statement: ts.Statement | undefined = sourceFile.statements.find(
(s) => ts.isTypeAliasDeclaration(s) && s.name.text === aliasName
);
if (!statement) {
throw new Error(`Type: '${aliasName}' not found in file: '${filename}'`);
}
const type: ts.Type = typeChecker.getTypeAtLocation(statement);
const fields: string[] = [];
// Iterate over the `ts.Symbol`s representing Property Nodes of `ts.Type`
for (const prop of type.getProperties()) {
const name: string = prop.getName();
const propType: ts.Type = typeChecker.getTypeOfSymbolAtLocation(prop, statement);
const propTypeName: string = typeChecker.typeToString(propType);
fields.push(`${name}: ${propTypeName};`);
}
return `type ${aliasName} = {\n ${fields.join("\n ")}\n}`;
}
const typeBSignature = extractTypeSignature("./src/my-file.ts", "TypeB");
// write to file or console log
console.log(typeBSignature);
/*
type TypeB = {
prop1: string;
}
*/
I've explicitly annotated all variables to show where the types are coming from. Even though it's a small script, I'd recommend writing compiler scripts in TypeScript rather than JavaScript and executing with tsc file.ts && node file.js or using something like ts-node, as the type inference/typeguards are very useful when navigating the compiler API.
const TypeC = ..., how would I? I tried changing it to isVariableDeclaration but the code complains that Property 'text' does not exist on type 'BindingName' for ...s.name.text....
kind on each node and then compare it to the SyntaxKind enum in typescript.d.ts. the kind on a const statement is 232, so I see it's a VariableStatement, and use the ts.isVariableStatement(s) typeguard, then dig into the available props. const a = 1,b = 2; is valid JS/TS syntax, so I noticed there is a declarationList on that node type, and each of those declarations has a name.getText().
type IMyPaymentEntities = NonNullable<UnwrapPromise<typeof fetchMyPaymentEntities>>;
If you want to omit some types that you will be going to share with a third party then you will need to use @internal:
type First = {
propA: string
/** @internal */
propB: number
}
And use stripInternal flag in the configuration when you will generate the .d.ts file.
{
"include": ["aaa/**/*"],
"compilerOptions": {
"declaration": true,
"emitDeclarationOnly": true,
"outDir": "dist",
"stripInternal": true
}
}
type TypeB = Omit<TypeA, "prop2">; rather than type TypeB = { prop1: string; }. The other answer was able to extrapolate it.
console.log("value_you_want_to_see");jsonschema-definer