24285868201

Committed 11 Apr 2026 03:43PM UTC coverage: 99.044% (-1.0%) from 100.0%

Build # 24285868201

Build Type

Pull #702

github

Committed by

web-flow

Commit Message

Merge e5ef2596a into 83ea63ac1

Pull Request Pull Request #702: Load typescript dynamically

Coverage Stats

294 of 334 branches covered (88.02%)

96 of 101 new or added lines in 3 files covered. (95.05%)

1 existing line in 1 file now uncovered.

518 of 523 relevant lines covered (99.04%)

212.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.36

/zod-sockets/src/typescript-api.ts

import * as R from "ramda";
import type ts from "typescript";

export type Typeable =
  | ts.TypeNode
  | ts.Identifier
  | string
  | ts.KeywordTypeSyntaxKind;

type TypeParams =
  | string[]
  | Partial<Record<string, Typeable | { type?: ts.TypeNode; init: Typeable }>>;

export class TypescriptAPI {
  public ts: typeof ts;
  public f: typeof ts.factory;
  public exportModifier: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>[];
  public asyncModifier: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>[];
  public accessModifiers: Record<
    "public" | "publicStatic" | "protectedReadonly",
    ts.Modifier[]
  >;
  #primitives: ts.KeywordTypeSyntaxKind[];
  static #safePropRegex = /^[A-Za-z_$][A-Za-z0-9_$]*$/;

  constructor(typescript: typeof ts) {
    this.ts = typescript;
    this.f = this.ts.factory;
    this.exportModifier = [
      this.f.createModifier(this.ts.SyntaxKind.ExportKeyword),
    ];
    this.asyncModifier = [
      this.f.createModifier(this.ts.SyntaxKind.AsyncKeyword),
    ];
    this.accessModifiers = {
      public: [this.f.createModifier(this.ts.SyntaxKind.PublicKeyword)],
      publicStatic: [
        this.f.createModifier(this.ts.SyntaxKind.PublicKeyword),
        this.f.createModifier(this.ts.SyntaxKind.StaticKeyword),
      ],
      protectedReadonly: [
        this.f.createModifier(this.ts.SyntaxKind.ProtectedKeyword),
        this.f.createModifier(this.ts.SyntaxKind.ReadonlyKeyword),
      ],
    };
    this.#primitives = [
      this.ts.SyntaxKind.AnyKeyword,
      this.ts.SyntaxKind.BigIntKeyword,
      this.ts.SyntaxKind.BooleanKeyword,
      this.ts.SyntaxKind.NeverKeyword,
      this.ts.SyntaxKind.NumberKeyword,
      this.ts.SyntaxKind.ObjectKeyword,
      this.ts.SyntaxKind.StringKeyword,
      this.ts.SyntaxKind.SymbolKeyword,
      this.ts.SyntaxKind.UndefinedKeyword,
      this.ts.SyntaxKind.UnknownKeyword,
      this.ts.SyntaxKind.VoidKeyword,
    ];
  }

  public addJsDoc = <T extends ts.Node>(node: T, text: string) =>
    this.ts.addSyntheticLeadingComment(
      node,
      this.ts.SyntaxKind.MultiLineCommentTrivia,
      `* ${text} `,
      true,
    );

  public printNode = (node: ts.Node, printerOptions?: ts.PrinterOptions) => {
    const sourceFile = this.ts.createSourceFile(
      "print.ts",
      "",
      this.ts.ScriptTarget.Latest,
      false,
      this.ts.ScriptKind.TS,
    );
    const printer = this.ts.createPrinter(printerOptions);
    return printer.printNode(this.ts.EmitHint.Unspecified, node, sourceFile);
  };

  public makeId = (name: string) => this.f.createIdentifier(name);

  public makePropertyIdentifier = (name: string | number) =>
    typeof name === "string" && TypescriptAPI.#safePropRegex.test(name)
      ? this.makeId(name)
      : this.literally(name);

  public ensureTypeNode = (
    subject: Typeable,
    args?: Typeable[], // only for string and id
  ): ts.TypeNode =>
    typeof subject === "number"
      ? this.f.createKeywordTypeNode(subject)
      : typeof subject === "string" || this.ts.isIdentifier(subject)
        ? this.f.createTypeReferenceNode(
            subject,
            args && R.map(this.ensureTypeNode, args),
          )
        : subject;

  /**
   * @internal
   * ensures distinct union (unique primitives)
   * */
  public makeUnion = (entries: ts.TypeNode[]) => {
    const nodes = new Map<
      ts.TypeNode | ts.KeywordTypeSyntaxKind,
      ts.TypeNode
    >();
    for (const entry of entries)
      nodes.set(this.isPrimitive(entry) ? entry.kind : entry, entry);
    return this.f.createUnionTypeNode(Array.from(nodes.values()));
  };

  public makeInterfaceProp = (
    name: string | number,
    value: Typeable,
    {
      isOptional,
      hasUndefined = isOptional,
      isDeprecated,
      comment,
    }: {
      isOptional?: boolean;
      hasUndefined?: boolean;
      isDeprecated?: boolean;
      comment?: string;
    } = {},
  ) => {
    const propType = this.ensureTypeNode(value);
    const node = this.f.createPropertySignature(
      undefined,
      this.makePropertyIdentifier(name),
      isOptional
        ? this.f.createToken(this.ts.SyntaxKind.QuestionToken)
        : undefined,
      hasUndefined
        ? this.makeUnion([
            propType,
            this.ensureTypeNode(this.ts.SyntaxKind.UndefinedKeyword),
          ])
        : propType,
    );
    const jsdoc = R.reject(R.isNil, [
      isDeprecated ? "@deprecated" : undefined,
      comment,
    ]);
    return jsdoc.length ? this.addJsDoc(node, jsdoc.join(" ")) : node;
  };

  public makeConst = (
    name: string | ts.Identifier | ts.ArrayBindingPattern,
    value: ts.Expression,
    { type, expose }: { type?: Typeable; expose?: true } = {},
  ) =>
    this.f.createVariableStatement(
      expose && this.exportModifier,
      this.f.createVariableDeclarationList(
        [
          this.f.createVariableDeclaration(
            name,
            undefined,
            type ? this.ensureTypeNode(type) : undefined,
            value,
          ),
        ],
        this.ts.NodeFlags.Const,
      ),
    );

  public makeType = (
    name: ts.Identifier | string,
    value: ts.TypeNode,
    {
      expose,
      comment,
      params,
    }: { expose?: boolean; comment?: string; params?: TypeParams } = {},
  ) => {
    const node = this.f.createTypeAliasDeclaration(
      expose ? this.exportModifier : undefined,
      name,
      params && this.makeTypeParams(params),
      value,
    );
    return comment ? this.addJsDoc(node, comment) : node;
  };

  public makeInterface = (
    name: ts.Identifier | string,
    props: ts.PropertySignature[],
    { expose, comment }: { expose?: boolean; comment?: string } = {},
  ) => {
    const node = this.f.createInterfaceDeclaration(
      expose ? this.exportModifier : undefined,
      name,
      undefined,
      undefined,
      props,
    );
    return comment ? this.addJsDoc(node, comment) : node;
  };

  public makeTypeParams = (
    params:
      | string[]
      | Partial<
          Record<string, Typeable | { type?: ts.TypeNode; init: Typeable }>
        >,
  ) =>
    (Array.isArray(params)
      ? params.map((name) => R.pair(name, undefined))
      : Object.entries(params)
    ).map(([name, val]) => {
      const { type, init } =
        typeof val === "object" && "init" in val ? val : { type: val };
      return this.f.createTypeParameterDeclaration(
        [],
        name,
        type ? this.ensureTypeNode(type) : undefined,
        init ? this.ensureTypeNode(init) : undefined,
      );
    });

  /* eslint-disable prettier/prettier -- shorter and works better this way than overrides */
  public literally = <T extends string | null | boolean | number | bigint>(subj: T) => (
      typeof subj === "number" ? this.f.createNumericLiteral(subj)
          : typeof subj === "bigint" ? this.f.createBigIntLiteral(subj.toString())
              : typeof subj === "boolean" ? subj ? this.f.createTrue() : this.f.createFalse()
                  : subj === null ? this.f.createNull() : this.f.createStringLiteral(subj)
  ) as T extends string ? ts.StringLiteral : T extends number ? ts.NumericLiteral
      : T extends boolean ? ts.BooleanLiteral : ts.NullLiteral;
  /* eslint-enable prettier/prettier */

  public makeLiteralType = (subj: Parameters<typeof this.literally>[0]) =>
    this.f.createLiteralTypeNode(this.literally(subj));

  public isPrimitive = (node: ts.TypeNode): node is ts.KeywordTypeNode =>
    (this.#primitives as ts.SyntaxKind[]).includes(node.kind);
}

1	import * as R from "ramda";
2	import type ts from "typescript";
3
4	export type Typeable =
5	\| ts.TypeNode
6	\| ts.Identifier
7	\| string
8	\| ts.KeywordTypeSyntaxKind;
9
10	type TypeParams =
11	\| string[]
12	\| Partial<Record<string, Typeable \| { type?: ts.TypeNode; init: Typeable }>>;
13
14	export class TypescriptAPI {
15	public ts: typeof ts;
16	public f: typeof ts.factory;
17	public exportModifier: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>[];
18	public asyncModifier: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>[];
19	public accessModifiers: Record<
20	"public" \| "publicStatic" \| "protectedReadonly",
21	ts.Modifier[]
22	>;
23	#primitives: ts.KeywordTypeSyntaxKind[];
24	static #safePropRegex = /^[A-Za-z_$][A-Za-z0-9_$]*$/;	18✔
25
26	constructor(typescript: typeof ts) {
27	this.ts = typescript;	12✔
28	this.f = this.ts.factory;	12✔
29	this.exportModifier = [	12✔
30	this.f.createModifier(this.ts.SyntaxKind.ExportKeyword),
31	];
32	this.asyncModifier = [	12✔
33	this.f.createModifier(this.ts.SyntaxKind.AsyncKeyword),
34	];
35	this.accessModifiers = {	12✔
36	public: [this.f.createModifier(this.ts.SyntaxKind.PublicKeyword)],
37	publicStatic: [
38	this.f.createModifier(this.ts.SyntaxKind.PublicKeyword),
39	this.f.createModifier(this.ts.SyntaxKind.StaticKeyword),
40	],
41	protectedReadonly: [
42	this.f.createModifier(this.ts.SyntaxKind.ProtectedKeyword),
43	this.f.createModifier(this.ts.SyntaxKind.ReadonlyKeyword),
44	],
45	};
46	this.#primitives = [	12✔
47	this.ts.SyntaxKind.AnyKeyword,
48	this.ts.SyntaxKind.BigIntKeyword,
49	this.ts.SyntaxKind.BooleanKeyword,
50	this.ts.SyntaxKind.NeverKeyword,
51	this.ts.SyntaxKind.NumberKeyword,
52	this.ts.SyntaxKind.ObjectKeyword,
53	this.ts.SyntaxKind.StringKeyword,
54	this.ts.SyntaxKind.SymbolKeyword,
55	this.ts.SyntaxKind.UndefinedKeyword,
56	this.ts.SyntaxKind.UnknownKeyword,
57	this.ts.SyntaxKind.VoidKeyword,
58	];
59	}
60
61	public addJsDoc = <T extends ts.Node>(node: T, text: string) =>	24✔
62	this.ts.addSyntheticLeadingComment(	24✔
63	node,
64	this.ts.SyntaxKind.MultiLineCommentTrivia,
65	`* ${text} `,
66	true,
67	);
68
69	public printNode = (node: ts.Node, printerOptions?: ts.PrinterOptions) => {	208✔
70	const sourceFile = this.ts.createSourceFile(	208✔
71	"print.ts",
72	"",
73	this.ts.ScriptTarget.Latest,
74	false,
75	this.ts.ScriptKind.TS,
76	);
77	const printer = this.ts.createPrinter(printerOptions);	208✔
78	return printer.printNode(this.ts.EmitHint.Unspecified, node, sourceFile);	208✔
79	};
80
81	public makeId = (name: string) => this.f.createIdentifier(name);	500✔
82
83	public makePropertyIdentifier = (name: string \| number) =>	536✔
84	typeof name === "string" && TypescriptAPI.#safePropRegex.test(name)	536✔
85	? this.makeId(name)
86	: this.literally(name);
87
88	public ensureTypeNode = (	1,304✔
89	subject: Typeable,
90	args?: Typeable[], // only for string and id
91	): ts.TypeNode =>
92	typeof subject === "number"	1,304✔
93	? this.f.createKeywordTypeNode(subject)
94	: typeof subject === "string" \|\| this.ts.isIdentifier(subject)	1,800✔
95	? this.f.createTypeReferenceNode(
96	subject,
97	args && R.map(this.ensureTypeNode, args),	68✔
98	)
99	: subject;
100
101	/**
102	* @internal
103	* ensures distinct union (unique primitives)
104	* */
105	public makeUnion = (entries: ts.TypeNode[]) => {	140✔
106	const nodes = new Map<	140✔
107	ts.TypeNode \| ts.KeywordTypeSyntaxKind,
108	ts.TypeNode
109	>();
110	for (const entry of entries)	140✔
111	nodes.set(this.isPrimitive(entry) ? entry.kind : entry, entry);	336✔
112	return this.f.createUnionTypeNode(Array.from(nodes.values()));	140✔
113	};
114
115	public makeInterfaceProp = (	536✔
116	name: string \| number,
117	value: Typeable,
118	{	536✔
119	isOptional,
120	hasUndefined = isOptional,	536✔
121	isDeprecated,
122	comment,
123	}: {
124	isOptional?: boolean;
125	hasUndefined?: boolean;
126	isDeprecated?: boolean;
127	comment?: string;
128	} = {},
129	) => {
130	const propType = this.ensureTypeNode(value);	536✔
131	const node = this.f.createPropertySignature(	536✔
132	undefined,
133	this.makePropertyIdentifier(name),
134	isOptional	536✔
135	? this.f.createToken(this.ts.SyntaxKind.QuestionToken)
136	: undefined,
137	hasUndefined	536✔
138	? this.makeUnion([
139	propType,
140	this.ensureTypeNode(this.ts.SyntaxKind.UndefinedKeyword),
141	])
142	: propType,
143	);
144	const jsdoc = R.reject(R.isNil, [	536✔
145	isDeprecated ? "@deprecated" : undefined,	536!
146	comment,
147	]);
148	return jsdoc.length ? this.addJsDoc(node, jsdoc.join(" ")) : node;	536✔
149	};
150
151	public makeConst = (	8✔
152	name: string \| ts.Identifier \| ts.ArrayBindingPattern,
153	value: ts.Expression,
154	{ type, expose }: { type?: Typeable; expose?: true } = {},	8✔
155	) =>
156	this.f.createVariableStatement(	8✔
157	expose && this.exportModifier,	16✔
158	this.f.createVariableDeclarationList(
159	[
160	this.f.createVariableDeclaration(
161	name,
162	undefined,
163	type ? this.ensureTypeNode(type) : undefined,	8!
164	value,
165	),
166	],
167	this.ts.NodeFlags.Const,
168	),
169	);
170
171	public makeType = (	16✔
172	name: ts.Identifier \| string,
173	value: ts.TypeNode,
174	{	16✔
175	expose,
176	comment,
177	params,
178	}: { expose?: boolean; comment?: string; params?: TypeParams } = {},
179	) => {
180	const node = this.f.createTypeAliasDeclaration(	16✔
181	expose ? this.exportModifier : undefined,	16✔
182	name,
183	params && this.makeTypeParams(params),	16!
184	value,
185	);
186	return comment ? this.addJsDoc(node, comment) : node;	16!
187	};
188
189	public makeInterface = (	16✔
190	name: ts.Identifier \| string,
191	props: ts.PropertySignature[],
192	{ expose, comment }: { expose?: boolean; comment?: string } = {},	16✔
193	) => {
194	const node = this.f.createInterfaceDeclaration(	16✔
195	expose ? this.exportModifier : undefined,	16!
196	name,
197	undefined,
198	undefined,
199	props,
200	);
201	return comment ? this.addJsDoc(node, comment) : node;	16!
202	};
203
NEW 204	public makeTypeParams = (	×
NEW 205	params:	×
206	\| string[]
207	\| Partial<
208	Record<string, Typeable \| { type?: ts.TypeNode; init: Typeable }>
209	>,
210	) =>
211	(Array.isArray(params)	×
NEW UNCOV 212	? params.map((name) => R.pair(name, undefined))	×
213	: Object.entries(params)
214	).map(([name, val]) => {
215	const { type, init } =
NEW 216	typeof val === "object" && "init" in val ? val : { type: val };	×
NEW 217	return this.f.createTypeParameterDeclaration(	×
218	[],
219	name,
220	type ? this.ensureTypeNode(type) : undefined,	×
221	init ? this.ensureTypeNode(init) : undefined,	×
222	);
223	});
224
225	/* eslint-disable prettier/prettier -- shorter and works better this way than overrides */
226	public literally = <T extends string \| null \| boolean \| number \| bigint>(subj: T) => (	228✔
227	typeof subj === "number" ? this.f.createNumericLiteral(subj)	228✔
228	: typeof subj === "bigint" ? this.f.createBigIntLiteral(subj.toString())	196!
229	: typeof subj === "boolean" ? subj ? this.f.createTrue() : this.f.createFalse()	204✔
230	: subj === null ? this.f.createNull() : this.f.createStringLiteral(subj)	188✔
231	) as T extends string ? ts.StringLiteral : T extends number ? ts.NumericLiteral
232	: T extends boolean ? ts.BooleanLiteral : ts.NullLiteral;
233	/* eslint-enable prettier/prettier */
234
235	public makeLiteralType = (subj: Parameters<typeof this.literally>[0]) =>	192✔
236	this.f.createLiteralTypeNode(this.literally(subj));	192✔
237
238	public isPrimitive = (node: ts.TypeNode): node is ts.KeywordTypeNode =>	336✔
239	(this.#primitives as ts.SyntaxKind[]).includes(node.kind);	336✔
240	}

RobinTail / zod-sockets / 24285868201

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous