@kubb/parser-ts 3.16.1 → 3.16.3

package/dist/chunk-Cl8Af3a2.js

@@ -0,0 +1,11 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+export { __export };

package/dist/factory-CTKjALU5.js

@@ -0,0 +1,254 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import ts from "typescript";
+import { isNumber } from "remeda";
+
+//#region src/factory.ts
+var factory_exports = {};
+__export(factory_exports, {
+	appendJSDocToNode: () => appendJSDocToNode,
+	createArrayDeclaration: () => createArrayDeclaration,
+	createArrayTypeNode: () => createArrayTypeNode,
+	createEnumDeclaration: () => createEnumDeclaration,
+	createExportDeclaration: () => createExportDeclaration,
+	createFalse: () => createFalse,
+	createIdentifier: () => createIdentifier,
+	createImportDeclaration: () => createImportDeclaration,
+	createIndexSignature: () => createIndexSignature,
+	createInterfaceDeclaration: () => createInterfaceDeclaration,
+	createIntersectionDeclaration: () => createIntersectionDeclaration,
+	createJSDoc: () => createJSDoc,
+	createLiteralTypeNode: () => createLiteralTypeNode,
+	createNamespaceDeclaration: () => createNamespaceDeclaration,
+	createNull: () => createNull,
+	createNumericLiteral: () => createNumericLiteral,
+	createOmitDeclaration: () => createOmitDeclaration,
+	createOptionalTypeNode: () => createOptionalTypeNode,
+	createParameterSignature: () => createParameterSignature,
+	createPropertySignature: () => createPropertySignature,
+	createQuestionToken: () => createQuestionToken,
+	createRestTypeNode: () => createRestTypeNode,
+	createStringLiteral: () => createStringLiteral,
+	createTrue: () => createTrue,
+	createTupleDeclaration: () => createTupleDeclaration,
+	createTupleTypeNode: () => createTupleTypeNode,
+	createTypeAliasDeclaration: () => createTypeAliasDeclaration,
+	createTypeDeclaration: () => createTypeDeclaration,
+	createTypeLiteralNode: () => createTypeLiteralNode,
+	createTypeReferenceNode: () => createTypeReferenceNode,
+	createUnionDeclaration: () => createUnionDeclaration,
+	keywordTypeNodes: () => keywordTypeNodes,
+	modifiers: () => modifiers,
+	syntaxKind: () => syntaxKind
+});
+const { SyntaxKind, factory } = ts;
+const modifiers = {
+	async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+	export: factory.createModifier(ts.SyntaxKind.ExportKeyword),
+	const: factory.createModifier(ts.SyntaxKind.ConstKeyword),
+	static: factory.createModifier(ts.SyntaxKind.StaticKeyword)
+};
+const syntaxKind = { union: SyntaxKind.UnionType };
+function isValidIdentifier(str) {
+	if (!str.length || str.trim() !== str) return false;
+	const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
+	return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind) === void 0;
+}
+function propertyName(name) {
+	if (typeof name === "string") return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
+	return name;
+}
+const questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);
+function createQuestionToken(token) {
+	if (!token) return void 0;
+	if (token === true) return questionToken;
+	return token;
+}
+function createIntersectionDeclaration({ nodes, withParentheses }) {
+	if (!nodes.length) return null;
+	if (nodes.length === 1) return nodes[0] || null;
+	const node = factory.createIntersectionTypeNode(nodes);
+	if (withParentheses) return factory.createParenthesizedType(node);
+	return node;
+}
+/**
+* Minimum nodes length of 2
+* @example `string & number`
+*/
+function createTupleDeclaration({ nodes, withParentheses }) {
+	if (!nodes.length) return null;
+	if (nodes.length === 1) return nodes[0] || null;
+	const node = factory.createTupleTypeNode(nodes);
+	if (withParentheses) return factory.createParenthesizedType(node);
+	return node;
+}
+function createArrayDeclaration({ nodes }) {
+	if (!nodes.length) return factory.createTupleTypeNode([]);
+	if (nodes.length === 1) return factory.createArrayTypeNode(nodes.at(0));
+	return factory.createExpressionWithTypeArguments(factory.createIdentifier("Array"), [factory.createUnionTypeNode(nodes)]);
+}
+/**
+* Minimum nodes length of 2
+* @example `string | number`
+*/
+function createUnionDeclaration({ nodes, withParentheses }) {
+	if (!nodes.length) return keywordTypeNodes.any;
+	if (nodes.length === 1) return nodes[0];
+	const node = factory.createUnionTypeNode(nodes);
+	if (withParentheses) return factory.createParenthesizedType(node);
+	return node;
+}
+function createPropertySignature({ readOnly, modifiers: modifiers$1 = [], name, questionToken: questionToken$1, type }) {
+	return factory.createPropertySignature([...modifiers$1, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : void 0].filter(Boolean), propertyName(name), createQuestionToken(questionToken$1), type);
+}
+function createParameterSignature(name, { modifiers: modifiers$1, dotDotDotToken, questionToken: questionToken$1, type, initializer }) {
+	return factory.createParameterDeclaration(modifiers$1, dotDotDotToken, name, createQuestionToken(questionToken$1), type, initializer);
+}
+function createJSDoc({ comments }) {
+	if (!comments.length) return null;
+	return factory.createJSDocComment(factory.createNodeArray(comments.map((comment, i) => {
+		if (i === comments.length - 1) return factory.createJSDocText(comment);
+		return factory.createJSDocText(`${comment}\n`);
+	})));
+}
+/**
+* @link https://github.com/microsoft/TypeScript/issues/44151
+*/
+function appendJSDocToNode({ node, comments }) {
+	const filteredComments = comments.filter(Boolean);
+	if (!filteredComments.length) return node;
+	const text = filteredComments.reduce((acc = "", comment = "") => {
+		return `${acc}\n * ${comment.replaceAll("*/", "*\\/")}`;
+	}, "*");
+	return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text || "*"}\n`, true);
+}
+function createIndexSignature(type, { modifiers: modifiers$1, indexName = "key", indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword) } = {}) {
+	return factory.createIndexSignature(modifiers$1, [createParameterSignature(indexName, { type: indexType })], type);
+}
+function createTypeAliasDeclaration({ modifiers: modifiers$1, name, typeParameters, type }) {
+	return factory.createTypeAliasDeclaration(modifiers$1, name, typeParameters, type);
+}
+function createInterfaceDeclaration({ modifiers: modifiers$1, name, typeParameters, members }) {
+	return factory.createInterfaceDeclaration(modifiers$1, name, typeParameters, void 0, members);
+}
+function createTypeDeclaration({ syntax, isExportable, comments, name, type }) {
+	if (syntax === "interface" && "members" in type) {
+		const node$1 = createInterfaceDeclaration({
+			members: type.members,
+			modifiers: isExportable ? [modifiers.export] : [],
+			name,
+			typeParameters: void 0
+		});
+		return appendJSDocToNode({
+			node: node$1,
+			comments
+		});
+	}
+	const node = createTypeAliasDeclaration({
+		type,
+		modifiers: isExportable ? [modifiers.export] : [],
+		name,
+		typeParameters: void 0
+	});
+	return appendJSDocToNode({
+		node,
+		comments
+	});
+}
+function createNamespaceDeclaration({ statements, name }) {
+	return factory.createModuleDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(name), factory.createModuleBlock(statements), ts.NodeFlags.Namespace);
+}
+/**
+* In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.
+* @example `import { Pet as Cat } from './Pet'`
+*/
+function createImportDeclaration({ name, path, isTypeOnly = false, isNameSpace = false }) {
+	if (!Array.isArray(name)) {
+		let importPropertyName = factory.createIdentifier(name);
+		let importName;
+		if (isNameSpace) {
+			importPropertyName = void 0;
+			importName = factory.createNamespaceImport(factory.createIdentifier(name));
+		}
+		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, importPropertyName, importName), factory.createStringLiteral(path), void 0);
+	}
+	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(name.map((item) => {
+		if (typeof item === "object") {
+			const obj = item;
+			if (obj.name) return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name));
+			return factory.createImportSpecifier(false, void 0, factory.createIdentifier(obj.propertyName));
+		}
+		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
+	}))), factory.createStringLiteral(path), void 0);
+}
+function createExportDeclaration({ path, asAlias, isTypeOnly = false, name }) {
+	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true ${name}`);
+	if (!Array.isArray(name)) {
+		const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
+		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
+	}
+	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(name.map((propertyName$1) => {
+		return factory.createExportSpecifier(false, void 0, typeof propertyName$1 === "string" ? factory.createIdentifier(propertyName$1) : propertyName$1);
+	})), factory.createStringLiteral(path), void 0);
+}
+function createEnumDeclaration({ type = "enum", name, typeName, enums }) {
+	if (type === "literal") return [void 0, factory.createTypeAliasDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createUnionTypeNode(enums.map(([_key, value]) => {
+		if (isNumber(value)) return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()));
+		if (typeof value === "boolean") return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse());
+		if (value) return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()));
+		return void 0;
+	}).filter(Boolean)))];
+	if (type === "enum" || type === "constEnum") return [void 0, factory.createEnumDeclaration([factory.createToken(ts.SyntaxKind.ExportKeyword), type === "constEnum" ? factory.createToken(ts.SyntaxKind.ConstKeyword) : void 0].filter(Boolean), factory.createIdentifier(typeName), enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		const isExactNumber = Number.parseInt(value.toString(), 10) === value;
+		if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if (isNumber(Number.parseInt(key.toString(), 10))) return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer);
+		if (key) return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer);
+		return void 0;
+	}).filter(Boolean))];
+	const identifierName = type === "asPascalConst" ? typeName : name;
+	return [factory.createVariableStatement([factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(identifierName), void 0, void 0, factory.createAsExpression(factory.createObjectLiteralExpression(enums.map(([key, value]) => {
+		let initializer = factory.createStringLiteral(value?.toString());
+		if (isNumber(value)) if (value < 0) initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)));
+		else initializer = factory.createNumericLiteral(value);
+		if (typeof value === "boolean") initializer = value ? factory.createTrue() : factory.createFalse();
+		if (key) return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer);
+		return void 0;
+	}).filter(Boolean), true), factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)))], ts.NodeFlags.Const)), factory.createTypeAliasDeclaration(type === "asPascalConst" ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier(typeName), void 0, factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0)), factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), void 0))))];
+}
+function createOmitDeclaration({ keys, type, nonNullable }) {
+	const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier("NonNullable"), [type]) : type;
+	if (Array.isArray(keys)) return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createUnionTypeNode(keys.map((key) => {
+		return factory.createLiteralTypeNode(factory.createStringLiteral(key));
+	}))]);
+	return factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))]);
+}
+const keywordTypeNodes = {
+	any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+	unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+	void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),
+	number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+	integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+	object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
+	string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+	boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+	undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+	null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword))
+};
+const createTypeLiteralNode = factory.createTypeLiteralNode;
+const createTypeReferenceNode = factory.createTypeReferenceNode;
+const createNumericLiteral = factory.createNumericLiteral;
+const createStringLiteral = factory.createStringLiteral;
+const createArrayTypeNode = factory.createArrayTypeNode;
+const createLiteralTypeNode = factory.createLiteralTypeNode;
+const createNull = factory.createNull;
+const createIdentifier = factory.createIdentifier;
+const createOptionalTypeNode = factory.createOptionalTypeNode;
+const createTupleTypeNode = factory.createTupleTypeNode;
+const createRestTypeNode = factory.createRestTypeNode;
+const createTrue = factory.createTrue;
+const createFalse = factory.createFalse;
+
+//#endregion
+export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, factory_exports, keywordTypeNodes, modifiers, syntaxKind };
+//# sourceMappingURL=factory-CTKjALU5.js.map

package/dist/factory-CTKjALU5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-CTKjALU5.js","names":["str: string","name: string | ts.PropertyName","token?: boolean | ts.QuestionToken","modifiers","questionToken","name: string | ts.BindingName","type: ts.TypeNode","node","importPropertyName: ts.Identifier | undefined","importName: ts.NamedImportBindings | undefined","propertyName","initializer: ts.Expression"],"sources":["../src/factory.ts"],"sourcesContent":["import { isNumber } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n  async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n  export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n  const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n  static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n  union: SyntaxKind.UnionType as 192,\n} as const\n\nfunction isValidIdentifier(str: string): boolean {\n  if (!str.length || str.trim() !== str) {\n    return false\n  }\n  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n  return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string | ts.PropertyName): ts.PropertyName {\n  if (typeof name === 'string') {\n    return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n  }\n  return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean | ts.QuestionToken) {\n  if (!token) {\n    return undefined\n  }\n  if (token === true) {\n    return questionToken\n  }\n  return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createIntersectionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string & number`\n */\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createTupleTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createArrayDeclaration({ nodes }: { nodes: Array<ts.TypeNode> }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return factory.createTupleTypeNode([])\n  }\n\n  if (nodes.length === 1) {\n    return factory.createArrayTypeNode(nodes.at(0)!)\n  }\n\n  return factory.createExpressionWithTypeArguments(factory.createIdentifier('Array'), [factory.createUnionTypeNode(nodes)])\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string | number`\n */\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n  if (!nodes.length) {\n    return keywordTypeNodes.any\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] as ts.TypeNode\n  }\n\n  const node = factory.createUnionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createPropertySignature({\n  readOnly,\n  modifiers = [],\n  name,\n  questionToken,\n  type,\n}: {\n  readOnly?: boolean\n  modifiers?: Array<ts.Modifier>\n  name: ts.PropertyName | string\n  questionToken?: ts.QuestionToken | boolean\n  type?: ts.TypeNode\n}) {\n  return factory.createPropertySignature(\n    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n    propertyName(name),\n    createQuestionToken(questionToken),\n    type,\n  )\n}\n\nexport function createParameterSignature(\n  name: string | ts.BindingName,\n  {\n    modifiers,\n    dotDotDotToken,\n    questionToken,\n    type,\n    initializer,\n  }: {\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n    dotDotDotToken?: ts.DotDotDotToken\n    questionToken?: ts.QuestionToken | boolean\n    type?: ts.TypeNode\n    initializer?: ts.Expression\n  },\n): ts.ParameterDeclaration {\n  return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n  if (!comments.length) {\n    return null\n  }\n  return factory.createJSDocComment(\n    factory.createNodeArray(\n      comments.map((comment, i) => {\n        if (i === comments.length - 1) {\n          return factory.createJSDocText(comment)\n        }\n\n        return factory.createJSDocText(`${comment}\\n`)\n      }),\n    ),\n  )\n}\n\n/**\n * @link https://github.com/microsoft/TypeScript/issues/44151\n */\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string | undefined> }) {\n  const filteredComments = comments.filter(Boolean)\n\n  if (!filteredComments.length) {\n    return node\n  }\n\n  const text = filteredComments.reduce((acc = '', comment = '') => {\n    return `${acc}\\n * ${comment.replaceAll('*/', '*\\\\/')}`\n  }, '*')\n\n  // node: {...node}, with that ts.addSyntheticLeadingComment is appending\n  return ts.addSyntheticLeadingComment({ ...node }, ts.SyntaxKind.MultiLineCommentTrivia, `${text || '*'}\\n`, true)\n}\n\nexport function createIndexSignature(\n  type: ts.TypeNode,\n  {\n    modifiers,\n    indexName = 'key',\n    indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  }: {\n    indexName?: string\n    indexType?: ts.TypeNode\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n  } = {},\n) {\n  return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  type,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  type: ts.TypeNode\n}) {\n  return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  members,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  members: Array<ts.TypeElement>\n}) {\n  return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n  syntax,\n  isExportable,\n  comments,\n  name,\n  type,\n}: {\n  syntax: 'type' | 'interface'\n  comments: Array<string | undefined>\n  isExportable?: boolean\n  name: string | ts.Identifier\n  type: ts.TypeNode\n}) {\n  if (syntax === 'interface' && 'members' in type) {\n    const node = createInterfaceDeclaration({\n      members: type.members as Array<ts.TypeElement>,\n      modifiers: isExportable ? [modifiers.export] : [],\n      name,\n      typeParameters: undefined,\n    })\n\n    return appendJSDocToNode({\n      node,\n      comments,\n    })\n  }\n\n  const node = createTypeAliasDeclaration({\n    type,\n    modifiers: isExportable ? [modifiers.export] : [],\n    name,\n    typeParameters: undefined,\n  })\n\n  return appendJSDocToNode({\n    node,\n    comments,\n  })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n  return factory.createModuleDeclaration(\n    [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n    factory.createIdentifier(name),\n    factory.createModuleBlock(statements),\n    ts.NodeFlags.Namespace,\n  )\n}\n\n/**\n * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n */\nexport function createImportDeclaration({\n  name,\n  path,\n  isTypeOnly = false,\n  isNameSpace = false,\n}: {\n  name: string | Array<string | { propertyName: string; name?: string }>\n  path: string\n  isTypeOnly?: boolean\n  isNameSpace?: boolean\n}) {\n  if (!Array.isArray(name)) {\n    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)\n    let importName: ts.NamedImportBindings | undefined\n\n    if (isNameSpace) {\n      importPropertyName = undefined\n      importName = factory.createNamespaceImport(factory.createIdentifier(name))\n    }\n\n    return factory.createImportDeclaration(\n      undefined,\n      factory.createImportClause(isTypeOnly, importPropertyName, importName),\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  return factory.createImportDeclaration(\n    undefined,\n    factory.createImportClause(\n      isTypeOnly,\n      undefined,\n      factory.createNamedImports(\n        name.map((item) => {\n          if (typeof item === 'object') {\n            const obj = item as { propertyName: string; name?: string }\n            if (obj.name) {\n              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n            }\n\n            return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n          }\n\n          return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n        }),\n      ),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport function createExportDeclaration({\n  path,\n  asAlias,\n  isTypeOnly = false,\n  name,\n}: {\n  path: string\n  asAlias?: boolean\n  isTypeOnly?: boolean\n  name?: string | Array<ts.Identifier | string>\n}) {\n  if (name && !Array.isArray(name) && !asAlias) {\n    console.warn(`When using name as string, asAlias should be true ${name}`)\n  }\n\n  if (!Array.isArray(name)) {\n    const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n    return factory.createExportDeclaration(\n      undefined,\n      isTypeOnly,\n      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  return factory.createExportDeclaration(\n    undefined,\n    isTypeOnly,\n    factory.createNamedExports(\n      name.map((propertyName) => {\n        return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n      }),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport function createEnumDeclaration({\n  type = 'enum',\n  name,\n  typeName,\n  enums,\n}: {\n  /**\n   * @default `'enum'`\n   */\n  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'\n  /**\n   * Enum name in camelCase.\n   */\n  name: string\n  /**\n   * Enum name in PascalCase.\n   */\n  typeName: string\n  enums: [key: string | number, value: string | number | boolean][]\n}): [name: ts.Node | undefined, type: ts.Node] {\n  if (type === 'literal') {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createUnionTypeNode(\n          enums\n            .map(([_key, value]) => {\n              if (isNumber(value)) {\n                return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n              }\n\n              if (typeof value === 'boolean') {\n                return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n              }\n              if (value) {\n                return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n              }\n\n              return undefined\n            })\n            .filter(Boolean),\n        ),\n      ),\n    ]\n  }\n\n  if (type === 'enum' || type === 'constEnum') {\n    return [\n      undefined,\n      factory.createEnumDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n        factory.createIdentifier(typeName),\n        enums\n          .map(([key, value]) => {\n            let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n            const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n            if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n              initializer = factory.createNumericLiteral(value as number)\n            }\n\n            if (typeof value === 'boolean') {\n              initializer = value ? factory.createTrue() : factory.createFalse()\n            }\n\n            if (isNumber(Number.parseInt(key.toString(), 10))) {\n              return factory.createEnumMember(factory.createStringLiteral(`${typeName}_${key}`), initializer)\n            }\n\n            if (key) {\n              return factory.createEnumMember(factory.createStringLiteral(`${key}`), initializer)\n            }\n\n            return undefined\n          })\n          .filter(Boolean),\n      ),\n    ]\n  }\n\n  // used when using `as const` instead of an TypeScript enum.\n  const identifierName = type === 'asPascalConst' ? typeName : name\n\n  return [\n    factory.createVariableStatement(\n      [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createVariableDeclarationList(\n        [\n          factory.createVariableDeclaration(\n            factory.createIdentifier(identifierName),\n            undefined,\n            undefined,\n            factory.createAsExpression(\n              factory.createObjectLiteralExpression(\n                enums\n                  .map(([key, value]) => {\n                    let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n                    if (isNumber(value)) {\n                      // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n                      // The method createNumericLiteral only accepts positive numbers\n                      // or those combined with createPrefixUnaryExpression.\n                      // Therefore, we need to ensure that the number is not negative.\n                      if (value < 0) {\n                        initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n                      } else {\n                        initializer = factory.createNumericLiteral(value)\n                      }\n                    }\n\n                    if (typeof value === 'boolean') {\n                      initializer = value ? factory.createTrue() : factory.createFalse()\n                    }\n\n                    if (key) {\n                      return factory.createPropertyAssignment(factory.createStringLiteral(`${key}`), initializer)\n                    }\n\n                    return undefined\n                  })\n                  .filter(Boolean),\n                true,\n              ),\n              factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n            ),\n          ),\n        ],\n        ts.NodeFlags.Const,\n      ),\n    ),\n    factory.createTypeAliasDeclaration(\n      type === 'asPascalConst' ? [] : [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createIdentifier(typeName),\n      undefined,\n      factory.createIndexedAccessTypeNode(\n        factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n        factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n      ),\n    ),\n  ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> | string; type: ts.TypeNode; nonNullable?: boolean }) {\n  const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n  if (Array.isArray(keys)) {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n      node,\n      factory.createUnionTypeNode(\n        keys.map((key) => {\n          return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n        }),\n      ),\n    ])\n  }\n\n  return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n  unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n  void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n  null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n} as const\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\n"],"mappings":"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"}

package/dist/factory-CUjjpSgy.d.ts

@@ -0,0 +1,230 @@
+import ts from "typescript";
+
+//#region src/factory.d.ts
+declare namespace factory_d_exports {
+  export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, keywordTypeNodes, modifiers, syntaxKind };
+}
+declare const modifiers: {
+  readonly async: ts.ModifierToken<ts.SyntaxKind.AsyncKeyword>;
+  readonly export: ts.ModifierToken<ts.SyntaxKind.ExportKeyword>;
+  readonly const: ts.ModifierToken<ts.SyntaxKind.ConstKeyword>;
+  readonly static: ts.ModifierToken<ts.SyntaxKind.StaticKeyword>;
+};
+declare const syntaxKind: {
+  readonly union: 192;
+};
+declare function createQuestionToken(token?: boolean | ts.QuestionToken): ts.PunctuationToken<ts.SyntaxKind.QuestionToken> | undefined;
+declare function createIntersectionDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode | null;
+/**
+ * Minimum nodes length of 2
+ * @example `string & number`
+ */
+declare function createTupleDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode | null;
+declare function createArrayDeclaration({
+  nodes
+}: {
+  nodes: Array<ts.TypeNode>;
+}): ts.TypeNode | null;
+/**
+ * Minimum nodes length of 2
+ * @example `string | number`
+ */
+declare function createUnionDeclaration({
+  nodes,
+  withParentheses
+}: {
+  nodes: Array<ts.TypeNode>;
+  withParentheses?: boolean;
+}): ts.TypeNode;
+declare function createPropertySignature({
+  readOnly,
+  modifiers,
+  name,
+  questionToken,
+  type
+}: {
+  readOnly?: boolean;
+  modifiers?: Array<ts.Modifier>;
+  name: ts.PropertyName | string;
+  questionToken?: ts.QuestionToken | boolean;
+  type?: ts.TypeNode;
+}): ts.PropertySignature;
+declare function createParameterSignature(name: string | ts.BindingName, {
+  modifiers,
+  dotDotDotToken,
+  questionToken,
+  type,
+  initializer
+}: {
+  decorators?: Array<ts.Decorator>;
+  modifiers?: Array<ts.Modifier>;
+  dotDotDotToken?: ts.DotDotDotToken;
+  questionToken?: ts.QuestionToken | boolean;
+  type?: ts.TypeNode;
+  initializer?: ts.Expression;
+}): ts.ParameterDeclaration;
+declare function createJSDoc({
+  comments
+}: {
+  comments: string[];
+}): ts.JSDoc | null;
+/**
+ * @link https://github.com/microsoft/TypeScript/issues/44151
+ */
+declare function appendJSDocToNode<TNode extends ts.Node>({
+  node,
+  comments
+}: {
+  node: TNode;
+  comments: Array<string | undefined>;
+}): TNode;
+declare function createIndexSignature(type: ts.TypeNode, {
+  modifiers,
+  indexName,
+  indexType
+}?: {
+  indexName?: string;
+  indexType?: ts.TypeNode;
+  decorators?: Array<ts.Decorator>;
+  modifiers?: Array<ts.Modifier>;
+}): ts.IndexSignatureDeclaration;
+declare function createTypeAliasDeclaration({
+  modifiers,
+  name,
+  typeParameters,
+  type
+}: {
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+  typeParameters?: Array<ts.TypeParameterDeclaration>;
+  type: ts.TypeNode;
+}): ts.TypeAliasDeclaration;
+declare function createInterfaceDeclaration({
+  modifiers,
+  name,
+  typeParameters,
+  members
+}: {
+  modifiers?: Array<ts.Modifier>;
+  name: string | ts.Identifier;
+  typeParameters?: Array<ts.TypeParameterDeclaration>;
+  members: Array<ts.TypeElement>;
+}): ts.InterfaceDeclaration;
+declare function createTypeDeclaration({
+  syntax,
+  isExportable,
+  comments,
+  name,
+  type
+}: {
+  syntax: 'type' | 'interface';
+  comments: Array<string | undefined>;
+  isExportable?: boolean;
+  name: string | ts.Identifier;
+  type: ts.TypeNode;
+}): ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
+declare function createNamespaceDeclaration({
+  statements,
+  name
+}: {
+  name: string;
+  statements: ts.Statement[];
+}): ts.ModuleDeclaration;
+/**
+ * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.
+ * @example `import { Pet as Cat } from './Pet'`
+ */
+declare function createImportDeclaration({
+  name,
+  path,
+  isTypeOnly,
+  isNameSpace
+}: {
+  name: string | Array<string | {
+    propertyName: string;
+    name?: string;
+  }>;
+  path: string;
+  isTypeOnly?: boolean;
+  isNameSpace?: boolean;
+}): ts.ImportDeclaration;
+declare function createExportDeclaration({
+  path,
+  asAlias,
+  isTypeOnly,
+  name
+}: {
+  path: string;
+  asAlias?: boolean;
+  isTypeOnly?: boolean;
+  name?: string | Array<ts.Identifier | string>;
+}): ts.ExportDeclaration;
+declare function createEnumDeclaration({
+  type,
+  name,
+  typeName,
+  enums
+}: {
+  /**
+   * @default `'enum'`
+   */
+  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal';
+  /**
+   * Enum name in camelCase.
+   */
+  name: string;
+  /**
+   * Enum name in PascalCase.
+   */
+  typeName: string;
+  enums: [key: string | number, value: string | number | boolean][];
+}): [name: ts.Node | undefined, type: ts.Node];
+declare function createOmitDeclaration({
+  keys,
+  type,
+  nonNullable
+}: {
+  keys: Array<string> | string;
+  type: ts.TypeNode;
+  nonNullable?: boolean;
+}): ts.TypeReferenceNode;
+declare const keywordTypeNodes: {
+  readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
+  readonly unknown: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+  readonly void: ts.KeywordTypeNode<ts.SyntaxKind.VoidKeyword>;
+  readonly number: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+  readonly integer: ts.KeywordTypeNode<ts.SyntaxKind.NumberKeyword>;
+  readonly object: ts.KeywordTypeNode<ts.SyntaxKind.ObjectKeyword>;
+  readonly string: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+  readonly boolean: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+  readonly undefined: ts.KeywordTypeNode<ts.SyntaxKind.UndefinedKeyword>;
+  readonly null: ts.LiteralTypeNode;
+};
+declare const createTypeLiteralNode: (members: readonly ts.TypeElement[] | undefined) => ts.TypeLiteralNode;
+declare const createTypeReferenceNode: (typeName: string | ts.EntityName, typeArguments?: readonly ts.TypeNode[]) => ts.TypeReferenceNode;
+declare const createNumericLiteral: (value: string | number, numericLiteralFlags?: ts.TokenFlags) => ts.NumericLiteral;
+declare const createStringLiteral: (text: string, isSingleQuote?: boolean) => ts.StringLiteral;
+declare const createArrayTypeNode: (elementType: ts.TypeNode) => ts.ArrayTypeNode;
+declare const createLiteralTypeNode: (literal: ts.LiteralTypeNode["literal"]) => ts.LiteralTypeNode;
+declare const createNull: () => ts.NullLiteral;
+declare const createIdentifier: (text: string) => ts.Identifier;
+declare const createOptionalTypeNode: (type: ts.TypeNode) => ts.OptionalTypeNode;
+declare const createTupleTypeNode: (elements: readonly (ts.TypeNode | ts.NamedTupleMember)[]) => ts.TupleTypeNode;
+declare const createRestTypeNode: (type: ts.TypeNode) => ts.RestTypeNode;
+declare const createTrue: () => ts.TrueLiteral;
+declare const createFalse: () => ts.FalseLiteral;
+//#endregion
+export { appendJSDocToNode, createArrayDeclaration, createArrayTypeNode, createEnumDeclaration, createExportDeclaration, createFalse, createIdentifier, createImportDeclaration, createIndexSignature, createInterfaceDeclaration, createIntersectionDeclaration, createJSDoc, createLiteralTypeNode, createNamespaceDeclaration, createNull, createNumericLiteral, createOmitDeclaration, createOptionalTypeNode, createParameterSignature, createPropertySignature, createQuestionToken, createRestTypeNode, createStringLiteral, createTrue, createTupleDeclaration, createTupleTypeNode, createTypeAliasDeclaration, createTypeDeclaration, createTypeLiteralNode, createTypeReferenceNode, createUnionDeclaration, factory_d_exports, keywordTypeNodes, modifiers, syntaxKind };
+//# sourceMappingURL=factory-CUjjpSgy.d.ts.map