@himenon/openapi-typescript-code-generator
Version:
OpenAPI Code Generator using TypeScript AST.
1,564 lines (1,495 loc) • 172 kB
JavaScript
"use strict";
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 index_exports = {};
__export(index_exports, {
CodeGenerator: () => CodeGenerator
});
module.exports = __toCommonJS(index_exports);
var import_os5 = require("os");
// src/internal/TsGenerator/index.ts
var TsGenerator_exports = {};
__export(TsGenerator_exports, {
Factory: () => factory_exports,
Utils: () => utils_exports,
convertAstToTypeScriptCode: () => convertAstToTypeScriptCode,
generate: () => generate
});
var import_typescript19 = __toESM(require("typescript"), 1);
// src/internal/Exception/index.ts
var BaseError = class extends Error {
constructor(message) {
super(message);
Object.setPrototypeOf(this, new.target.prototype);
}
};
var UnSupportError = class extends BaseError {
};
var NotFoundFileError = class extends BaseError {
};
var FeatureDevelopmentError = class extends BaseError {
};
var UndefinedComponent = class extends BaseError {
};
var DevelopmentError = class extends BaseError {
};
// src/internal/TsGenerator/factory/index.ts
var factory_exports = {};
__export(factory_exports, {
create: () => create44
});
var import_typescript16 = __toESM(require("typescript"), 1);
// src/internal/TsGenerator/factory/ArrowFunction.ts
var create = ({ factory }) => (params) => {
const node = factory.createArrowFunction(
void 0,
params.typeParameters,
params.parameters,
params.type,
params.equalsGreaterThanToken,
params.body
);
return node;
};
var make = (context) => {
return {
create: create(context)
};
};
// src/internal/TsGenerator/factory/BinaryExpression.ts
var import_typescript = __toESM(require("typescript"), 1);
var operators = {
"+": import_typescript.default.SyntaxKind.PlusToken,
"=": import_typescript.default.SyntaxKind.EqualsToken
};
var create2 = ({ factory }) => (params) => {
const node = factory.createBinaryExpression(params.left, operators[params.operator], params.right);
return node;
};
var make2 = (context) => {
return {
create: create2(context)
};
};
// src/internal/TsGenerator/factory/Block.ts
var create3 = ({ factory }) => (params) => {
const node = factory.createBlock(params.statements, params.multiLine);
return node;
};
var make3 = (context) => {
return {
create: create3(context)
};
};
// src/internal/TsGenerator/factory/CallExpression.ts
var create4 = ({ factory }) => (params) => {
const node = factory.createCallExpression(params.expression, params.typeArguments, params.argumentsArray);
return node;
};
var make4 = (context) => {
return {
create: create4(context)
};
};
// src/internal/TsGenerator/factory/ClassDeclaration.ts
var import_typescript2 = __toESM(require("typescript"), 1);
var create5 = ({ factory }) => (params) => {
const node = factory.createClassDeclaration(
params.export && [factory.createModifier(import_typescript2.default.SyntaxKind.ExportKeyword)],
factory.createIdentifier(params.name),
params.typeParameterDeclaration,
void 0,
params.members
);
return node;
};
var make5 = (context) => {
return {
create: create5(context)
};
};
// src/internal/TsGenerator/factory/ConstructorDeclaration.ts
var create6 = ({ factory }) => (params) => {
const node = factory.createConstructorDeclaration(void 0, params.parameters || [], params.body);
return node;
};
var make6 = (context) => {
return {
create: create6(context)
};
};
// src/internal/TsGenerator/factory/ElementAccessExpression.ts
var create7 = ({ factory }) => (params) => {
const index = typeof params.index === "string" ? factory.createStringLiteral(params.index) : params.index;
const node = factory.createElementAccessExpression(params.expression, index);
return node;
};
var make7 = (context) => {
return {
create: create7(context)
};
};
// src/internal/TsGenerator/factory/ExpressionStatement.ts
var create8 = ({ factory }) => (params) => {
const node = factory.createExpressionStatement(params.expression);
return node;
};
var make8 = (context) => {
return {
create: create8(context)
};
};
// src/internal/TsGenerator/factory/FunctionTypeNode.ts
var create9 = ({ factory }) => (params) => {
const node = factory.createFunctionTypeNode(params.typeParameters, params.parameters, params.type);
return node;
};
var make9 = (context) => {
return {
create: create9(context)
};
};
// src/internal/TsGenerator/factory/Identifier.ts
var create10 = ({ factory }) => (params) => {
const node = factory.createIdentifier(params.name);
return node;
};
var make10 = (context) => {
return {
create: create10(context)
};
};
// src/internal/TsGenerator/factory/IndexSignatureDeclaration.ts
var import_typescript3 = __toESM(require("typescript"), 1);
var create11 = ({ factory }) => (params) => {
const node = factory.createIndexSignature(
void 0,
// TODO Feature Development: Refactoring
[
factory.createParameterDeclaration(
void 0,
void 0,
factory.createIdentifier(params.name),
void 0,
factory.createKeywordTypeNode(import_typescript3.default.SyntaxKind.StringKeyword),
void 0
)
],
params.type
);
return node;
};
var make11 = (context) => {
return {
create: create11(context)
};
};
// src/internal/TsGenerator/factory/IndexedAccessTypeNode.ts
var create12 = ({ factory }) => (params) => {
const node = factory.createIndexedAccessTypeNode(params.objectType, params.indexType);
return node;
};
var make12 = (context) => {
return {
create: create12(context)
};
};
// src/internal/TsGenerator/factory/InterfaceDeclaration.ts
var import_typescript4 = __toESM(require("typescript"), 1);
// src/internal/TsGenerator/factory/utils.ts
var import_os = require("os");
var escapeIdentiferText = (text) => {
return text.replace(/-/g, "_");
};
var generateComment = (comment, deprecated) => {
const excapedComment = comment.replace(/\*\//, "\\*\\\\/").replace(/\/\*/, "/\\\\*").replace(/\*\/\*/, "\\*\\/\\*");
const splitComments = deprecated ? ["@deprecated"].concat(excapedComment.split(/\r?\n/)) : excapedComment.split(/\r?\n/);
const comments = splitComments.filter((comment2, index) => {
if (index === splitComments.length - 1 && comment2 === "") {
return false;
}
return true;
});
if (comments.length === 1) {
return {
hasTrailingNewLine: true,
value: `* ${comments.join("")} `
};
}
return {
hasTrailingNewLine: true,
value: `*${import_os.EOL}${comments.map((comment2) => ` * ${comment2}`).join(import_os.EOL)}${import_os.EOL} `
};
};
// src/internal/TsGenerator/factory/InterfaceDeclaration.ts
var create13 = ({ factory }) => (params) => {
const node = import_typescript4.default.factory.createInterfaceDeclaration(
params.export && [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
factory.createIdentifier(escapeIdentiferText(params.name)),
params.typeParameters,
void 0,
params.members
);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript4.default.addSyntheticLeadingComment(node, import_typescript4.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make13 = (context) => {
return {
create: create13(context)
};
};
// src/internal/TsGenerator/factory/IntersectionTypeNode.ts
var create14 = ({ factory }) => (params) => {
const node = factory.createIntersectionTypeNode(params.typeNodes);
return node;
};
var make14 = (context) => {
return {
create: create14(context)
};
};
// src/internal/TsGenerator/factory/LiteralTypeNode.ts
var import_typescript5 = __toESM(require("typescript"), 1);
var create15 = ({ factory }) => (params) => {
const createNode = () => {
if (typeof params.value === "string") {
const literal = import_typescript5.default.setEmitFlags(factory.createStringLiteral(params.value), import_typescript5.default.EmitFlags.NoAsciiEscaping);
return factory.createLiteralTypeNode(literal);
}
if (typeof params.value === "number") {
return factory.createLiteralTypeNode(factory.createNumericLiteral(params.value));
}
return factory.createLiteralTypeNode(params.value ? factory.createTrue() : factory.createFalse());
};
const node = createNode();
if (params.comment) {
const comment = generateComment(params.comment);
return import_typescript5.default.addSyntheticLeadingComment(node, import_typescript5.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make15 = (context) => {
return {
create: create15(context)
};
};
// src/internal/TsGenerator/factory/MethodDeclaration.ts
var import_typescript6 = __toESM(require("typescript"), 1);
var create16 = ({ factory }) => (params) => {
const modifiers = [];
if (params.private) {
modifiers.push(factory.createModifier(import_typescript6.default.SyntaxKind.PrivateKeyword));
} else {
modifiers.push(factory.createModifier(import_typescript6.default.SyntaxKind.PublicKeyword));
}
if (params.async) {
modifiers.push(factory.createModifier(import_typescript6.default.SyntaxKind.AsyncKeyword));
}
const node = factory.createMethodDeclaration(
modifiers,
void 0,
factory.createIdentifier(params.name),
void 0,
params.typeParameters,
params.parameters || [],
params.type,
params.body
);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript6.default.addSyntheticLeadingComment(node, import_typescript6.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make16 = (context) => {
return {
create: create16(context)
};
};
// src/internal/TsGenerator/factory/Namespace.ts
var import_typescript7 = __toESM(require("typescript"), 1);
// src/internal/TsGenerator/factory/ModuleBlock.ts
var update = ({ factory }) => (params) => {
const { node, statements } = params;
return factory.updateModuleBlock(node, statements);
};
// src/internal/TsGenerator/factory/Namespace.ts
var findStatement = (_context) => (params) => {
let statement;
params.node.forEachChild((node) => {
if (import_typescript7.default.isModuleDeclaration(node) && node.name.text === params.name) {
statement = node;
}
});
return statement;
};
var create17 = ({ factory }) => (params) => {
const node = factory.createModuleDeclaration(
params.export && [factory.createModifier(import_typescript7.default.SyntaxKind.ExportKeyword)],
factory.createIdentifier(params.name),
factory.createModuleBlock(params.statements),
import_typescript7.default.NodeFlags.Namespace
);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript7.default.addSyntheticLeadingComment(node, import_typescript7.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var createMultiple = (context) => (params) => {
const names = params.names.reverse();
const firstName = names[0];
const restNames = names.slice(1, names.length);
const child = create17(context)({
export: true,
name: firstName,
statements: params.statements,
comment: params.comment,
deprecated: params.deprecated
});
return restNames.reduce((previousStatement, currentName) => {
return create17(context)({
export: true,
name: currentName,
statements: [previousStatement]
});
}, child);
};
var update2 = (context) => (params) => {
const { factory } = context;
const { node, statements } = params;
if (node.body && import_typescript7.default.isModuleBlock(node.body)) {
const body = update(context)({ node: node.body, statements });
return factory.updateModuleDeclaration(node, node.modifiers, node.name, body);
}
return factory.updateModuleDeclaration(node, node.modifiers, node.name, node.body);
};
var addStatements = (context) => (params) => {
const { factory } = context;
const { node, statements } = params;
if (node.body && import_typescript7.default.isModuleBlock(node.body)) {
const body = update(context)({ node: node.body, statements: node.body.statements.concat(statements) });
return factory.updateModuleDeclaration(node, node.modifiers, node.name, body);
}
return factory.updateModuleDeclaration(node, node.modifiers, node.name, node.body);
};
var make17 = (context) => {
return {
findNamespace: findStatement(context),
create: create17(context),
update: update2(context),
createMultiple: createMultiple(context),
addStatements: addStatements(context)
};
};
// src/internal/TsGenerator/factory/NoSubstitutionTemplateLiteral.ts
var create18 = ({ factory }) => (params) => {
const node = factory.createNoSubstitutionTemplateLiteral(params.text, params.rawText);
return node;
};
var make18 = (context) => {
return {
create: create18(context)
};
};
// src/internal/TsGenerator/factory/ObjectLiteralExpression.ts
var create19 = ({ factory }) => (params) => {
const node = factory.createObjectLiteralExpression(params.properties, params.multiLine);
return node;
};
var make19 = (context) => {
return {
create: create19(context)
};
};
// src/internal/TsGenerator/factory/ParameterDeclaration.ts
var import_typescript8 = __toESM(require("typescript"), 1);
var create20 = ({ factory }) => (params) => {
const modifiers = (() => {
if (params.modifiers === "private") {
return [factory.createModifier(import_typescript8.default.SyntaxKind.PrivateKeyword)];
}
if (params.modifiers === "public") {
return [factory.createModifier(import_typescript8.default.SyntaxKind.PublicKeyword)];
}
return;
})();
const node = factory.createParameterDeclaration(
modifiers,
void 0,
factory.createIdentifier(params.name),
params.optional && factory.createToken(import_typescript8.default.SyntaxKind.QuestionToken),
params.type,
void 0
);
return node;
};
var make20 = (context) => {
return {
create: create20(context)
};
};
// src/internal/TsGenerator/factory/PropertyAccessExpression.ts
var generateExpression = (factory) => {
return {
this: factory.createThis()
};
};
var create21 = ({ factory }) => (params) => {
let expression = typeof params.expression === "string" ? factory.createIdentifier(params.expression) : params.expression;
const expressionMap = generateExpression(factory);
if (typeof params.expression === "string" && params.expression in expressionMap) {
expression = generateExpression(factory)[params.expression];
}
const node = factory.createPropertyAccessExpression(expression, factory.createIdentifier(params.name));
return node;
};
var make21 = (context) => {
return {
create: create21(context)
};
};
// src/internal/TsGenerator/factory/PropertyAssignment.ts
var import_typescript9 = __toESM(require("typescript"), 1);
var create22 = ({ factory }) => (params) => {
const node = factory.createPropertyAssignment(params.name, params.initializer);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript9.default.addSyntheticLeadingComment(node, import_typescript9.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make22 = (context) => {
return {
create: create22(context)
};
};
// src/internal/TsGenerator/factory/PropertyDeclaration.ts
var create23 = ({ factory }) => (params) => {
const node = factory.createPropertyDeclaration(
params.modifiers,
params.name,
params.questionOrExclamationToken,
params.type,
params.initializer
);
return node;
};
var make23 = (context) => {
return {
create: create23(context)
};
};
// src/internal/TsGenerator/factory/PropertySignature.ts
var import_typescript10 = __toESM(require("typescript"), 1);
var create24 = ({ factory }) => (params) => {
const node = factory.createPropertySignature(
params.readOnly ? [factory.createModifier(import_typescript10.default.SyntaxKind.ReadonlyKeyword)] : void 0,
params.name,
params.optional ? factory.createToken(import_typescript10.default.SyntaxKind.QuestionToken) : void 0,
params.type
);
if (params.comment) {
const comment = generateComment(params.comment);
return import_typescript10.default.addSyntheticLeadingComment(node, import_typescript10.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make24 = (context) => {
return {
create: create24(context)
};
};
// src/internal/TsGenerator/factory/RegularExpressionLiteral.ts
var create25 = ({ factory }) => (params) => {
return factory.createRegularExpressionLiteral(params.text);
};
var make25 = (context) => {
return {
create: create25(context)
};
};
// src/internal/TsGenerator/factory/ReturnStatement.ts
var create26 = ({ factory }) => (params) => {
const node = factory.createReturnStatement(params.expression);
return node;
};
var make26 = (context) => {
return {
create: create26(context)
};
};
// src/internal/TsGenerator/factory/ShorthandPropertyAssignment.ts
var create27 = ({ factory }) => (params) => {
const node = factory.createShorthandPropertyAssignment(params.name, void 0);
return node;
};
var make27 = (context) => {
return {
create: create27(context)
};
};
// src/internal/TsGenerator/factory/StringLiteral.ts
var create28 = ({ factory }) => (params) => {
const node = factory.createStringLiteral(params.text, params.isSingleQuote);
return node;
};
var make28 = (context) => {
return {
create: create28(context)
};
};
// src/internal/TsGenerator/factory/TemplateExpression.ts
var create29 = ({ factory }) => (params) => {
const node = factory.createTemplateExpression(params.head, params.templateSpans);
return node;
};
var make29 = (context) => {
return {
create: create29(context)
};
};
// src/internal/TsGenerator/factory/TemplateHead.ts
var create30 = ({ factory }) => (params) => {
const node = factory.createTemplateHead(params.text, params.rawText, void 0);
return node;
};
var make30 = (context) => {
return {
create: create30(context)
};
};
// src/internal/TsGenerator/factory/TemplateMiddle.ts
var create31 = ({ factory }) => (params) => {
const node = factory.createTemplateMiddle(params.text, params.rawText, void 0);
return node;
};
var make31 = (context) => {
return {
create: create31(context)
};
};
// src/internal/TsGenerator/factory/TemplateSpan.ts
var create32 = ({ factory }) => (params) => {
const node = factory.createTemplateSpan(params.expression, params.literal);
return node;
};
var make32 = (context) => {
return {
create: create32(context)
};
};
// src/internal/TsGenerator/factory/TemplateTail.ts
var create33 = ({ factory }) => (params) => {
const node = factory.createTemplateTail(params.text, params.rawText);
return node;
};
var make33 = (context) => {
return {
create: create33(context)
};
};
// src/internal/TsGenerator/factory/TypeAliasDeclaration.ts
var import_typescript11 = __toESM(require("typescript"), 1);
var create34 = ({ factory }) => (params) => {
const node = factory.createTypeAliasDeclaration(
params.export && [factory.createModifier(import_typescript11.default.SyntaxKind.ExportKeyword)],
factory.createIdentifier(params.name),
void 0,
params.type
);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript11.default.addSyntheticLeadingComment(node, import_typescript11.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make34 = (context) => {
return {
create: create34(context)
};
};
// src/internal/TsGenerator/factory/TypeLiteralNode.ts
var create35 = ({ factory }) => (params) => {
const node = factory.createTypeLiteralNode(params.members);
return node;
};
var make35 = (context) => {
return {
create: create35(context)
};
};
// src/internal/TsGenerator/factory/TypeNode.ts
var import_typescript12 = __toESM(require("typescript"), 1);
// src/internal/TsGenerator/factory/UnionTypeNode.ts
var create36 = ({ factory }) => (params) => {
const node = factory.createUnionTypeNode(params.typeNodes);
return node;
};
var make36 = (context) => {
return {
create: create36(context)
};
};
// src/internal/TsGenerator/factory/TypeNode.ts
var create37 = (context) => (params) => {
const { factory } = context;
const literalTypeNode = create15(context);
const unionTypeNode = create36(context);
const createNode = () => {
switch (params.type) {
case "string":
if (params.enum) {
return unionTypeNode({
typeNodes: params.enum.map((value) => literalTypeNode({ value }))
});
}
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.StringKeyword);
case "number":
case "integer":
if (params.enum) {
return unionTypeNode({
typeNodes: params.enum.map((value) => literalTypeNode({ value }))
});
}
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.NumberKeyword);
case "boolean": {
if (params.enum) {
return unionTypeNode({
typeNodes: params.enum.map((value) => literalTypeNode({ value }))
});
}
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.BooleanKeyword);
}
case "object":
return factory.createTypeLiteralNode(params.value);
case "undefined":
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.UndefinedKeyword);
case "null":
return factory.createLiteralTypeNode(factory.createNull());
case "array":
return factory.createArrayTypeNode(params.value);
case "never":
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.NeverKeyword);
case "void":
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.VoidKeyword);
case "any":
return factory.createKeywordTypeNode(import_typescript12.default.SyntaxKind.AnyKeyword);
default:
throw new UnSupportError(`UnSupport Type: ${JSON.stringify(params)}`);
}
};
const node = createNode();
return node;
};
var make37 = (context) => {
return {
create: create37(context)
};
};
// src/internal/TsGenerator/factory/TypeOperatorNode.ts
var import_typescript13 = __toESM(require("typescript"), 1);
var syntaxKinds = {
keyof: import_typescript13.default.SyntaxKind.KeyOfKeyword,
unique: import_typescript13.default.SyntaxKind.UniqueKeyword,
readonly: import_typescript13.default.SyntaxKind.ReadonlyKeyword
};
var create38 = ({ factory }) => (params) => {
const node = factory.createTypeOperatorNode(syntaxKinds[params.syntaxKind], params.type);
return node;
};
var make38 = (context) => {
return {
create: create38(context)
};
};
// src/internal/TsGenerator/factory/TypeParameterDeclaration.ts
var create39 = ({ factory }) => (params) => {
const node = factory.createTypeParameterDeclaration([], factory.createIdentifier(params.name), params.constraint, params.defaultType);
return node;
};
var make39 = (context) => {
return {
create: create39(context)
};
};
// src/internal/TsGenerator/factory/TypeReferenceNode.ts
var create40 = ({ factory }) => (params) => {
const node = factory.createTypeReferenceNode(factory.createIdentifier(params.name), params.typeArguments);
return node;
};
var make40 = (context) => {
return {
create: create40(context)
};
};
// src/internal/TsGenerator/factory/VariableDeclaration.ts
var create41 = ({ factory }) => (params) => {
const node = factory.createVariableDeclaration(params.name, void 0, params.type, params.initializer);
return node;
};
var make41 = (context) => {
return {
create: create41(context)
};
};
// src/internal/TsGenerator/factory/VariableDeclarationList.ts
var import_typescript14 = __toESM(require("typescript"), 1);
var flags = {
const: import_typescript14.default.NodeFlags.Const
};
var create42 = ({ factory }) => (params) => {
const node = factory.createVariableDeclarationList(params.declarations, flags[params.flag]);
return node;
};
var make42 = (context) => {
return {
create: create42(context)
};
};
// src/internal/TsGenerator/factory/VariableStatement.ts
var import_typescript15 = __toESM(require("typescript"), 1);
var create43 = ({ factory }) => (params) => {
const node = factory.createVariableStatement(params.modifiers, params.declarationList);
if (params.comment) {
const comment = generateComment(params.comment, params.deprecated);
return import_typescript15.default.addSyntheticLeadingComment(node, import_typescript15.default.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
}
return node;
};
var make43 = (context) => {
return {
create: create43(context)
};
};
// src/internal/TsGenerator/factory/index.ts
var create44 = () => {
const context = {
factory: import_typescript16.default.factory
};
return {
ArrowFunction: make(context),
Block: make3(context),
ClassDeclaration: make5(context),
ParameterDeclaration: make20(context),
InterfaceDeclaration: make13(context),
IndexedAccessTypeNode: make12(context),
Namespace: make17(context),
PropertySignature: make24(context),
PropertyDeclaration: make23(context),
TypeAliasDeclaration: make34(context),
TypeNode: make37(context),
LiteralTypeNode: make15(context),
IndexSignatureDeclaration: make11(context),
UnionTypeNode: make36(context),
IntersectionTypeNode: make14(context),
TypeReferenceNode: make40(context),
TypeParameterDeclaration: make39(context),
TypeOperatorNode: make38(context),
MethodDeclaration: make16(context),
ConstructorDeclaration: make6(context),
ReturnStatement: make26(context),
VariableDeclaration: make41(context),
VariableDeclarationList: make42(context),
VariableStatement: make43(context),
BinaryExpression: make2(context),
PropertyAccessExpression: make21(context),
RegularExpressionLiteral: make25(context),
NoSubstitutionTemplateLiteral: make18(context),
TemplateSpan: make32(context),
TemplateExpression: make29(context),
TemplateHead: make30(context),
TemplateMiddle: make31(context),
TemplateTail: make33(context),
Identifier: make10(context),
ShorthandPropertyAssignment: make27(context),
PropertyAssignment: make22(context),
ObjectLiteralExpression: make19(context),
ElementAccessExpression: make7(context),
ExpressionStatement: make8(context),
CallExpression: make4(context),
StringLiteral: make28(context),
FunctionTypeNode: make9(context),
TypeLiteralNode: make35(context)
};
};
// src/internal/TsGenerator/traverse.ts
var import_typescript17 = __toESM(require("typescript"), 1);
var traverse = (create49) => (context) => (rootNode) => {
const visit = (node) => {
if (!import_typescript17.default.isSourceFile(node)) {
return node;
}
return context.factory.updateSourceFile(
node,
create49(context),
node.isDeclarationFile,
node.referencedFiles,
node.typeReferenceDirectives,
node.hasNoDefaultLib,
node.libReferenceDirectives
);
};
return import_typescript17.default.visitNode(rootNode, visit);
};
// src/internal/TsGenerator/utils.ts
var utils_exports = {};
__export(utils_exports, {
convertIntermediateCodes: () => convertIntermediateCodes,
stringToStatements: () => stringToStatements
});
var import_typescript18 = __toESM(require("typescript"), 1);
var stringToStatements = (code) => {
const source = import_typescript18.default.createSourceFile("", code, import_typescript18.default.ScriptTarget.ESNext, false, import_typescript18.default.ScriptKind.TS);
return Array.from(source.statements);
};
var convertIntermediateCodes = (intermediateCodes) => {
return intermediateCodes.reduce((result, intermediateCode) => {
if (typeof intermediateCode === "string") {
return [...result, ...stringToStatements(intermediateCode)];
}
return result.concat(intermediateCode);
}, []);
};
// src/internal/TsGenerator/index.ts
var convertAstToTypeScriptCode = (sourceFile) => {
const printer = import_typescript19.default.createPrinter();
return printer.printFile(sourceFile);
};
var generate = (createFunction) => {
const source = import_typescript19.default.createSourceFile("", "", import_typescript19.default.ScriptTarget.ESNext);
const transformers = [traverse(createFunction)];
const result = import_typescript19.default.transform(source, transformers);
result.dispose();
if (result.transformed.length > 1) {
throw new DevelopmentError("Invalid length");
}
return convertAstToTypeScriptCode(result.transformed[0]);
};
// src/internal/OpenApiTools/index.ts
var OpenApiTools_exports = {};
__export(OpenApiTools_exports, {
Comment: () => Comment_exports,
ConvertContext: () => ConverterContext_exports,
Parser: () => Parser
});
// src/internal/OpenApiTools/Comment.ts
var Comment_exports = {};
__export(Comment_exports, {
generateLeading: () => generateLeading
});
var import_os2 = require("os");
// package.json
var package_default = {
name: "@himenon/openapi-typescript-code-generator",
version: "1.1.0",
description: "OpenAPI Code Generator using TypeScript AST.",
keywords: [
"openapi",
"openapi3",
"openapi-codegen",
"openapi-generator",
"typescript",
"typescript-ast"
],
homepage: "https://github.com/Himenon/openapi-typescript-code-generator#readme",
bugs: {
url: "https://github.com/Himenon/openapi-typescript-code-generator/issues"
},
repository: {
type: "git",
url: "git@github.com:Himenon/openapi-typescript-code-generator.git"
},
license: "MIT",
author: {
name: "Himenon",
email: "k.himeno314@gmail.com",
url: "https://github.com/Himenon"
},
sideEffects: false,
type: "module",
exports: {
".": {
import: "./dist/index.js",
require: "./dist/index.cjs"
},
"./dist/api": {
import: "./dist/api.js",
require: "./dist/api.cjs"
},
"./dist/templates": {
import: "./dist/templates.js",
require: "./dist/templates.cjs"
},
"./dist/types": {
import: "./dist/types.js",
require: "./dist/types.cjs"
},
"./dist/meta": {
import: "./dist/meta.js",
require: "./dist/meta.cjs"
}
},
main: "./dist/index.js",
module: "./dist/index.js",
browser: "./dist/index.js",
types: "./dist/index.d.ts",
files: [
"dist",
"package.json"
],
scripts: {
build: "tsup",
clean: "pnpm ts ./scripts/clean.ts",
format: "biome format --write .",
"lerna:version:up": "lerna version --yes",
lint: "biome lint .",
"release:github:registry": "pnpm publish --no-git-checks --registry https://npm.pkg.github.com/:_authToken=${NODE_AUTH_TOKEN}",
"release:npm:registry": "pnpm publish --no-git-checks",
test: "run-p test:depcruise test:jest test:code:gen:* test:snapshot",
"test:code:gen": "run-p test:code:gen:*",
"test:code:gen:class": "pnpm ts ./scripts/testCodeGenWithClass.ts",
"test:code:gen:currying-function": "pnpm ts ./scripts/testCodeGenWithCurryingFunctional.ts",
"test:code:gen:function": "pnpm ts ./scripts/testCodeGenWithFunctional.ts",
"test:depcruise": "depcruise --validate .dependency-cruiser.cjs src",
"test:jest": "cross-env NODE_OPTIONS=--experimental-specifier-resolution=node jest -c ./jest.config.cjs --collect-coverage",
"test:snapshot": "jest -c ./jest.snapshot.config.cjs",
ts: "node --no-warnings=ExperimentalWarning --experimental-specifier-resolution=node --loader ts-node/esm",
"update:snapshot": "pnpm jest -c ./jest.snapshot.config.cjs --updateSnapshot",
validate: "pnpm ts ./scripts/validate.ts",
watch: "pnpm ts ./scripts/watch.ts"
},
"simple-git-hooks": {
"pre-commit": "pnpm lint-staged"
},
"lint-staged": {
"*.{js,jsx,json,yml,yaml,html,md,ts,tsx}": [
"biome format --no-errors-on-unmatched --write"
],
"package.json": [
"sort-package-json"
]
},
resolutions: {
"kind-of": "6.0.3",
"node-fetch": "2.6.1"
},
dependencies: {
"@types/json-schema": "7.0.15",
ajv: "8.17.1",
"js-yaml": "4.1.0"
},
devDependencies: {
"@biomejs/biome": "^2.0.0",
"@commitlint/cli": "19.8.1",
"@commitlint/config-conventional": "19.8.1",
"@himenon/path-oriented-data-structure": "1.0.2",
"@swc/core": "^1.12.1",
"@swc/helpers": "^0.5.17",
"@swc/jest": "^0.2.38",
"@types/chokidar": "2.1.7",
"@types/jest": "30.0.0",
"@types/js-yaml": "4.0.9",
"@types/node": "24.0.3",
"@types/rimraf": "4.0.5",
chokidar: "4.0.3",
"conventional-changelog-angular-all": "1.7.0",
cpy: "11.1.0",
"cross-env": "^7.0.3",
"dependency-cruiser": "16.10.3",
"dot-prop": "9.0.0",
execa: "9.6.0",
"generate-changelog": "1.8.0",
"import-sort-style-module": "6.0.0",
jest: "30.0.1",
"jest-cli": "30.0.1",
lerna: "8.2.2",
"lint-staged": "16.1.2",
"npm-run-all": "4.1.5",
"openapi-schema-validator": "12.1.3",
"read-package-up": "^11.0.0",
rimraf: "6.0.1",
"simple-git-hooks": "^2.13.0",
"sort-package-json": "3.2.1",
"ts-jest": "29.4.0",
"ts-node": "10.9.2",
tsup: "^8.5.0",
typescript: "5.3.3"
},
peerDependencies: {
typescript: ">=5"
},
packageManager: "pnpm@10.12.1",
engines: {
pnpm: ">=9"
},
publishConfig: {
access: "public"
},
importSort: {
".js, .jsx, .ts, .tsx": {
style: "module",
parser: "typescript"
}
}
};
// src/meta.ts
var Name = package_default.name;
var Version = package_default.version;
// src/internal/OpenApiTools/Comment.ts
var generateLeading = (schema) => {
const messages = [];
messages.push("");
messages.push(`Generated by ${Name} v${Version}`);
messages.push("");
messages.push(`OpenApi : ${schema.openapi}`);
messages.push("");
if (schema.info.license) {
if (schema.info.license.name) {
messages.push(`License : ${schema.info.license.name}`);
}
if (schema.info.license.url) {
messages.push(`Url : ${schema.info.license.url}`);
}
}
messages.push("");
return messages.map((message) => {
return `// ${message}`;
}).join(import_os2.EOL);
};
// src/internal/OpenApiTools/ConverterContext.ts
var ConverterContext_exports = {};
__export(ConverterContext_exports, {
create: () => create45
});
// src/utils.ts
var parameterName = (operationId) => `Parameter$${operationId}`;
var requestBodyName = (operationId) => `RequestBody$${operationId}`;
var argumentParamsTypeDeclaration = (operationId) => `Params$${operationId}`;
var responseName = (operationId, statusCode) => `Response$${operationId}$Status$${statusCode}`;
var requestContentType = (operationId) => `RequestContentType$${operationId}`;
var responseContentType = (operationId) => `ResponseContentType$${operationId}`;
var isAvailableVariableName = (text) => {
return /^[A-Za-z_0-9]+$/.test(text);
};
var isFirstCharacterIsValidText = (text) => {
return /^[A-Za-z]+/.test(text);
};
var escapeText = (text) => {
if (isAvailableVariableName(text) && isFirstCharacterIsValidText(text)) {
return text;
}
return `"${text}"`;
};
// src/internal/OpenApiTools/ConverterContext.ts
var createFormatSchemaToTypeNode = (factory, target) => {
const typeNodes = target.output.type.map((value) => {
return factory.TypeReferenceNode.create({
name: value
});
});
if (target.output.multiType === "allOf") {
return factory.IntersectionTypeNode.create({
typeNodes
});
}
return factory.UnionTypeNode.create({
typeNodes
});
};
var create45 = (factory, options) => {
const convertReservedWord = (word) => {
if (["import", "export"].includes(word)) {
return `${word}_`;
}
return word;
};
const convertString = (text) => {
if (isAvailableVariableName(text)) {
return text;
}
return text.replace(/-/g, "$").replace(/\//g, "$");
};
const convertOperationId = (text) => {
return convertString(text).replace(/[^a-zA-Z0-9_]/g, "$");
};
return {
escapeOperationIdText: (operationId) => {
return convertOperationId(operationId);
},
escapeDeclarationText: (text) => {
return convertReservedWord(convertString(text).replace(/\./g, "$"));
},
escapeReferenceDeclarationText: (text) => {
return convertReservedWord(convertString(text));
},
escapePropertySignatureName: (text) => {
return escapeText(text);
},
escapeTypeReferenceNodeName: (text) => {
return convertString(text);
},
generateResponseName: (operationId, statusCode) => {
return responseName(convertOperationId(operationId), statusCode);
},
generateArgumentParamsTypeDeclaration: (operationId) => {
return argumentParamsTypeDeclaration(convertOperationId(operationId));
},
generateRequestContentTypeName: (operationId) => {
return requestContentType(convertOperationId(operationId));
},
generateResponseContentTypeName: (operationId) => {
return responseContentType(convertOperationId(operationId));
},
generateParameterName: (operationId) => {
return parameterName(convertOperationId(operationId));
},
generateRequestBodyName: (operationId) => {
return requestBodyName(convertOperationId(operationId));
},
generateFunctionName: (operationId) => {
return convertOperationId(operationId);
},
convertFormatTypeNode: (schema) => {
const formatConversions = options?.formatConversions;
if (!formatConversions || formatConversions.length === 0) {
return;
}
if (typeof schema === "boolean") {
return;
}
if (!schema.format) {
return;
}
const target = formatConversions.find((formatConvertion) => formatConvertion.selector.format === schema.format);
if (!target) {
return;
}
return createFormatSchemaToTypeNode(factory, target);
}
};
};
// src/internal/OpenApiTools/Extractor.ts
var extractPickedParameter = (parameter) => {
return {
name: parameter.name,
in: parameter.in,
required: parameter.required,
style: parameter.style,
explode: parameter.explode
};
};
var extractResponseNamesByStatusCode = (type, responses) => {
const statusCodeList = [];
for (const [statusCodeLike, response] of Object.entries(responses || {})) {
const hasValidMediaType = Object.values(response.content || {}).filter((mediaType) => Object.values(mediaType).length > 0).length > 0;
if (!hasValidMediaType) {
continue;
}
if (typeof statusCodeLike === "string") {
const statusCodeNumberValue = parseInt(statusCodeLike, 10);
if (type === "success") {
if (200 <= statusCodeNumberValue && statusCodeNumberValue < 300) {
statusCodeList.push(statusCodeNumberValue.toString());
}
} else if (type === "error") {
if (400 <= statusCodeNumberValue && statusCodeNumberValue < 600) {
statusCodeList.push(statusCodeNumberValue.toString());
}
}
}
}
return statusCodeList;
};
var getRequestContentTypeList = (requestBody) => {
return Object.entries(requestBody.content).reduce((list, [key, mediaType]) => {
const hasValidContent = Object.values(mediaType).length > 0;
if (hasValidContent) {
return list.concat(key);
}
return list;
}, []);
};
var getSuccessResponseContentTypeList = (responses) => {
const contentTypeList = [];
for (const statusCode of extractResponseNamesByStatusCode("success", responses)) {
const response = responses[statusCode];
for (const [key, mediaType] of Object.entries(response.content || {})) {
if (Object.values(mediaType).length > 0) {
contentTypeList.push(key);
}
}
}
return Array.from(new Set(contentTypeList));
};
var hasQueryParameters = (parameters) => {
if (!parameters) {
return false;
}
return parameters.filter((parameter) => parameter.in === "query").length > 0;
};
var generateCodeGeneratorParamsArray = (store, converterContext, allowOperationIds) => {
const operationState = store.getNoReferenceOperationState();
const params = [];
for (const [operationId, item] of Object.entries(operationState)) {
if (allowOperationIds && !allowOperationIds.includes(operationId)) {
continue;
}
const responseSuccessNames = extractResponseNamesByStatusCode("success", item.responses).map(
(statusCode) => converterContext.generateResponseName(operationId, statusCode)
);
const responseErrorNames = extractResponseNamesByStatusCode("error", item.responses).map(
(statusCode) => converterContext.generateResponseName(operationId, statusCode)
);
const requestContentTypeList = item.requestBody ? getRequestContentTypeList(item.requestBody) : [];
const responseSuccessContentTypes = getSuccessResponseContentTypeList(item.responses);
const hasOver2RequestContentTypes = requestContentTypeList.length > 1;
const hasOver2SuccessNames = responseSuccessNames.length > 1;
const convertedParams = {
escapedOperationId: converterContext.escapeOperationIdText(operationId),
argumentParamsTypeDeclaration: converterContext.generateArgumentParamsTypeDeclaration(operationId),
functionName: converterContext.generateFunctionName(operationId),
requestContentTypeName: converterContext.generateRequestContentTypeName(operationId),
responseContentTypeName: converterContext.generateResponseContentTypeName(operationId),
parameterName: converterContext.generateParameterName(operationId),
requestBodyName: converterContext.generateRequestBodyName(operationId),
hasRequestBody: !!item.requestBody,
hasParameter: item.parameters ? item.parameters.length > 0 : false,
pickedParameters: item.parameters ? item.parameters.map(extractPickedParameter) : [],
requestContentTypes: requestContentTypeList,
requestFirstContentType: requestContentTypeList.length === 1 ? requestContentTypeList[0] : void 0,
responseSuccessNames,
responseFirstSuccessName: responseSuccessNames.length === 1 ? responseSuccessNames[0] : void 0,
has2OrMoreSuccessNames: hasOver2SuccessNames,
responseErrorNames,
has2OrMoreRequestContentTypes: hasOver2RequestContentTypes,
successResponseContentTypes: responseSuccessContentTypes,
successResponseFirstContentType: responseSuccessContentTypes.length === 1 ? responseSuccessContentTypes[0] : void 0,
has2OrMoreSuccessResponseContentTypes: responseSuccessContentTypes.length > 1,
hasAdditionalHeaders: hasOver2RequestContentTypes || hasOver2SuccessNames,
hasQueryParameters: hasQueryParameters(item.parameters)
};
const formatParams = {
operationId,
convertedParams,
operationParams: item
};
params.push(formatParams);
}
return params;
};
// src/internal/OpenApiTools/TypeNodeContext.ts
var Path = __toESM(require("path"), 1);
// node_modules/.pnpm/dot-prop@9.0.0/node_modules/dot-prop/index.js
var isObject = (value) => {
const type = typeof value;
return value !== null && (type === "object" || type === "function");
};
var disallowedKeys = /* @__PURE__ */ new Set([
"__proto__",
"prototype",
"constructor"
]);
var digits = new Set("0123456789");
function getPathSegments(path6) {
const parts = [];
let currentSegment = "";
let currentPart = "start";
let isIgnoring = false;
for (const character of path6) {
switch (character) {
case "\\": {
if (currentPart === "index") {
throw new Error("Invalid character in an index");
}
if (currentPart === "indexEnd") {
throw new Error("Invalid character after an index");
}
if (isIgnoring) {
currentSegment += character;
}
currentPart = "property";
isIgnoring = !isIgnoring;
break;
}
case ".": {
if (currentPart === "index") {
throw new Error("Invalid character in an index");
}
if (currentPart === "indexEnd") {
currentPart = "property";
break;
}
if (isIgnoring) {
isIgnoring = false;
currentSegment += character;
break;
}
if (disallowedKeys.has(currentSegment)) {
return [];
}
parts.push(currentSegment);
currentSegment = "";
currentPart = "property";
break;
}
case "[": {
if (currentPart === "index") {
throw new Error("Invalid character in an index");
}
if (currentPart === "indexEnd") {
currentPart = "index";
break;
}
if (isIgnoring) {
isIgnoring = false;
currentSegment += character;
break;
}
if (currentPart === "property") {
if (disallowedKeys.has(currentSegment)) {
return [];
}
parts.push(currentSegment);
currentSegment = "";
}
currentPart = "index";
break;
}
case "]": {
if (currentPart === "index") {
parts.push(Number.parseInt(currentSegment, 10));
currentSegment = "";
currentPart = "indexEnd";
break;
}
if (currentPart === "indexEnd") {
throw new Error("Invalid character after an index");
}
}
default: {
if (currentPart === "index" && !digits.has(character)) {
throw new Error("Invalid character in an index");
}
if (currentPart === "indexEnd") {
throw new Error("Invalid character after an index");
}
if (currentPart === "start") {
currentPart = "property";
}
if (isIgnoring) {
isIgnoring = false;
currentSegment += "\\";
}
currentSegment += character;
}
}
}
if (isIgnoring) {
currentSegment += "\\";
}
switch (currentPart) {
case "property": {
if (disallowedKeys.has(currentSegment)) {
return [];
}
parts.push(currentSegment);
break;
}
case "index": {
throw new Error("Index was not closed");
}
case "start": {
parts.push("");
break;
}
}
return parts;
}
function isStringIndex(object, key) {
if (typeof key !== "number" && Array.isArray(object)) {
const index = Number.parseInt(key, 10);
return Number.isInteger(index) && object[index] === object[key];
}
return false;
}
function getProperty(object, path6, value) {
if (!isObject(object) || typeof path6 !== "string") {
return value === void 0 ? object : value;
}
const pathArray = getPathSegments(path6);
if (pathArray.length === 0) {
return value;
}
for (let index = 0; index < pathArray.length; index++) {
const key = pathArray[index];
if (isStringIndex(object, key)) {
object = index === pathArray.length - 1 ? void 0 : null;
} else {
object = object[key];
}
if (object === void 0 || object === null) {
if (index !== pathArray.length - 1) {
return value;
}
break;
}
}
return object === void 0 ? value : object;
}
// src/internal/OpenApiTools/TypeNodeContext.ts
var import_typescript20 = __toESM(require("typescript"), 1);
// src/internal/OpenApiTools/Guard.ts
var isReference = (data) => {
if (typeof data !== "object" || data === null) {
return false;
}
return typeof data.$ref === "string";
};
var isObjectSchema = (schema) => {
return schema.type === "object";
};
var isHasNoMembersObject = (schema) => {
return Object.keys(schema).length === 0;
};
var isArraySchema = (schema) => {
return schema.type === "array";
};
var isPrimitiveSchema = (schema) => {
if (typeof schema.type !== "string") {
return false;
}
if (schema.type === "object") {
return false;
}
if (schema.type === "array") {
ret