1 | "use strict";
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | exports.addOptionalInformation = exports.addComment = exports.buildTypeReferenceNode = exports.buildTupleTypeNode = exports.buildUnionTypeNode = exports.buildTypeLiteralNode = exports.buildIndexSignatureNode = exports.buildPropertySignature = exports.buildTypeAliasNode = exports.buildInterfaceNode = exports.buildNamespaceNode = exports.buildBooleanLiteralTypeNode = exports.buildNumericLiteralTypeNode = exports.buildStringLiteralTypeNode = exports.buildSimpleArrayNode = exports.buildStringKeyword = exports.buildNeverKeyword = exports.buildAnyKeyword = exports.buildKeyword = void 0;
|
4 | var tslib_1 = require("tslib");
|
5 | var ts = tslib_1.__importStar(require("typescript"));
|
6 | var config_1 = tslib_1.__importDefault(require("./config"));
|
7 | var validateIdentifier_1 = require("./validateIdentifier");
|
8 | function buildTypeNameIdentifier(name) {
|
9 | return ts.createIdentifier(validateIdentifier_1.toValidIdentifier(name, config_1.default.target));
|
10 | }
|
11 | function buildPropertyNameIdentifier(name) {
|
12 | if (/^\d/.test(name)) {
|
13 | name = '$' + name;
|
14 | }
|
15 | if (validateIdentifier_1.checkInvalidCharacter(name, config_1.default.target)) {
|
16 | return ts.createIdentifier(name);
|
17 | }
|
18 | else {
|
19 | return ts.createStringLiteral(name);
|
20 | }
|
21 | }
|
22 | function buildKeyword(kind) {
|
23 | return ts.createKeywordTypeNode(kind);
|
24 | }
|
25 | exports.buildKeyword = buildKeyword;
|
26 | function buildAnyKeyword() {
|
27 | return buildKeyword(ts.SyntaxKind.AnyKeyword);
|
28 | }
|
29 | exports.buildAnyKeyword = buildAnyKeyword;
|
30 | function buildNeverKeyword() {
|
31 | return buildKeyword(ts.SyntaxKind.NeverKeyword);
|
32 | }
|
33 | exports.buildNeverKeyword = buildNeverKeyword;
|
34 | function buildStringKeyword() {
|
35 | return buildKeyword(ts.SyntaxKind.StringKeyword);
|
36 | }
|
37 | exports.buildStringKeyword = buildStringKeyword;
|
38 | function buildSimpleArrayNode(element) {
|
39 | return ts.createArrayTypeNode(element);
|
40 | }
|
41 | exports.buildSimpleArrayNode = buildSimpleArrayNode;
|
42 | function buildStringLiteralTypeNode(s) {
|
43 | return ts.createLiteralTypeNode(ts.createStringLiteral(s));
|
44 | }
|
45 | exports.buildStringLiteralTypeNode = buildStringLiteralTypeNode;
|
46 | function buildNumericLiteralTypeNode(n) {
|
47 | return ts.createLiteralTypeNode(ts.createNumericLiteral(n));
|
48 | }
|
49 | exports.buildNumericLiteralTypeNode = buildNumericLiteralTypeNode;
|
50 | function buildBooleanLiteralTypeNode(b) {
|
51 | return ts.createLiteralTypeNode(b ? ts.createTrue() : ts.createFalse());
|
52 | }
|
53 | exports.buildBooleanLiteralTypeNode = buildBooleanLiteralTypeNode;
|
54 | function buildNamespaceNode(name, statements, root) {
|
55 | var modifiers = root ? [ts.createModifier(ts.SyntaxKind.DeclareKeyword)] : undefined;
|
56 | return ts.createModuleDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), ts.createModuleBlock(statements), ts.NodeFlags.Namespace | ts.NodeFlags.ExportContext | ts.NodeFlags.ContextFlags);
|
57 | }
|
58 | exports.buildNamespaceNode = buildNamespaceNode;
|
59 | function buildInterfaceNode(id, members, root) {
|
60 | var name = getLastTypeName(id);
|
61 | var modifiers = root ?
|
62 | [ts.createModifier(ts.SyntaxKind.DeclareKeyword)] :
|
63 | [ts.createModifier(ts.SyntaxKind.ExportKeyword)];
|
64 | return ts.createInterfaceDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), undefined, undefined, members);
|
65 | }
|
66 | exports.buildInterfaceNode = buildInterfaceNode;
|
67 | function buildTypeAliasNode(id, type, root) {
|
68 | var name = getLastTypeName(id);
|
69 | var modifiers = root ?
|
70 | [ts.createModifier(ts.SyntaxKind.DeclareKeyword)] :
|
71 | [ts.createModifier(ts.SyntaxKind.ExportKeyword)];
|
72 | return ts.createTypeAliasDeclaration(undefined, modifiers, buildTypeNameIdentifier(name), undefined, type);
|
73 | }
|
74 | exports.buildTypeAliasNode = buildTypeAliasNode;
|
75 | function buildPropertySignature(schema, propertyName, valueType, required) {
|
76 | var content = schema.content;
|
77 | var modifiers = 'readOnly' in content && content.readOnly ? [ts.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : undefined;
|
78 | var questionToken = required == null || required.indexOf(propertyName) < 0 ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined;
|
79 | return ts.createPropertySignature(modifiers, buildPropertyNameIdentifier(propertyName), questionToken, valueType, undefined);
|
80 | }
|
81 | exports.buildPropertySignature = buildPropertySignature;
|
82 | function buildIndexSignatureNode(name, indexType, valueType) {
|
83 | return ts.createIndexSignature(undefined, undefined, [ts.createParameter(undefined, undefined, undefined, buildTypeNameIdentifier(name), undefined, indexType, undefined)], valueType);
|
84 | }
|
85 | exports.buildIndexSignatureNode = buildIndexSignatureNode;
|
86 | function buildTypeLiteralNode(elements) {
|
87 | return ts.createTypeLiteralNode(elements);
|
88 | }
|
89 | exports.buildTypeLiteralNode = buildTypeLiteralNode;
|
90 | function buildUnionTypeNode(types, builder, terminate) {
|
91 | var node = ts.createUnionTypeNode(types.map(builder));
|
92 | if (terminate) {
|
93 | return node;
|
94 | }
|
95 | return ts.createParenthesizedType(node);
|
96 | }
|
97 | exports.buildUnionTypeNode = buildUnionTypeNode;
|
98 | function buildTupleTypeNode(types, minItems, maxItems) {
|
99 | var nodes = [];
|
100 | var itemCount = maxItems != null ? maxItems
|
101 | : Math.max(types.length, minItems || 0);
|
102 | for (var i = 0; i < itemCount; i++) {
|
103 | var node = i < types.length ? types[i] : buildAnyKeyword();
|
104 | if (minItems == null || i >= minItems) {
|
105 | node = ts.createOptionalTypeNode(node);
|
106 | }
|
107 | nodes.push(node);
|
108 | }
|
109 | if (maxItems == null) {
|
110 | nodes.push(ts.createRestTypeNode(ts.createArrayTypeNode(buildAnyKeyword())));
|
111 | }
|
112 | return ts.createTupleTypeNode(nodes);
|
113 | }
|
114 | exports.buildTupleTypeNode = buildTupleTypeNode;
|
115 | function buildTypeReferenceNode(schema, currentSchema) {
|
116 | var typeName = getTypename(schema.id, currentSchema);
|
117 | if (typeName.length === 0) {
|
118 | throw new Error('TypeName array must not be empty.');
|
119 | }
|
120 | var node = buildTypeNameIdentifier(typeName[0]);
|
121 | for (var i = 1; i < typeName.length; i++) {
|
122 | node = ts.createQualifiedName(node, buildTypeNameIdentifier(typeName[i]));
|
123 | }
|
124 | return ts.createTypeReferenceNode(node, undefined);
|
125 | }
|
126 | exports.buildTypeReferenceNode = buildTypeReferenceNode;
|
127 | function getTypename(id, baseSchema) {
|
128 | var e_1, _a;
|
129 | var result = id.toNames();
|
130 | var baseId = baseSchema.id;
|
131 | if (baseId) {
|
132 | var baseTypes = baseId.toNames().slice(0, -1);
|
133 | try {
|
134 | for (var baseTypes_1 = tslib_1.__values(baseTypes), baseTypes_1_1 = baseTypes_1.next(); !baseTypes_1_1.done; baseTypes_1_1 = baseTypes_1.next()) {
|
135 | var type = baseTypes_1_1.value;
|
136 | if (result.length === 1) {
|
137 | break;
|
138 | }
|
139 | if (result[0] === type) {
|
140 | result.shift();
|
141 | }
|
142 | else {
|
143 | break;
|
144 | }
|
145 | }
|
146 | }
|
147 | catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
148 | finally {
|
149 | try {
|
150 | if (baseTypes_1_1 && !baseTypes_1_1.done && (_a = baseTypes_1.return)) _a.call(baseTypes_1);
|
151 | }
|
152 | finally { if (e_1) throw e_1.error; }
|
153 | }
|
154 | }
|
155 | return result;
|
156 | }
|
157 | function addComment(node, schema, terminate) {
|
158 | var e_2, _a;
|
159 | var comments = getComment(schema);
|
160 | if (comments.length === 0) {
|
161 | return node;
|
162 | }
|
163 | else if (!terminate && comments.length === 1) {
|
164 | return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, " " + comments[0] + " ", false);
|
165 | }
|
166 | else {
|
167 | var result = '*\n';
|
168 | try {
|
169 | for (var comments_1 = tslib_1.__values(comments), comments_1_1 = comments_1.next(); !comments_1_1.done; comments_1_1 = comments_1.next()) {
|
170 | var comment = comments_1_1.value;
|
171 | result += ' * ' + comment + '\n';
|
172 | }
|
173 | }
|
174 | catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
175 | finally {
|
176 | try {
|
177 | if (comments_1_1 && !comments_1_1.done && (_a = comments_1.return)) _a.call(comments_1);
|
178 | }
|
179 | finally { if (e_2) throw e_2.error; }
|
180 | }
|
181 | result += ' ';
|
182 | return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, result, true);
|
183 | }
|
184 | }
|
185 | exports.addComment = addComment;
|
186 | function getComment(schema) {
|
187 | var e_3, _a;
|
188 | var content = schema.content;
|
189 | var comments = [];
|
190 | function protectComment(str) {
|
191 | return str.replace(/\*\//g, '*\u200B/');
|
192 | }
|
193 | function appendComment(value) {
|
194 | if (value == null) {
|
195 | return;
|
196 | }
|
197 | var s = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
|
198 | var lines = s.split('\n').map(function (line) { return protectComment(line); });
|
199 | comments = comments.concat.apply(comments, tslib_1.__spread(lines));
|
200 | }
|
201 | if ('$comment' in content) {
|
202 | appendComment(content.$comment);
|
203 | }
|
204 | appendComment(content.title);
|
205 | appendComment(content.description);
|
206 | if ('example' in content || 'examples' in content) {
|
207 | appendComment('example:');
|
208 | if ('example' in content) {
|
209 | appendComment(content.example);
|
210 | }
|
211 | if ('examples' in content) {
|
212 | if (content.examples) {
|
213 | try {
|
214 | for (var _b = tslib_1.__values(content.examples), _c = _b.next(); !_c.done; _c = _b.next()) {
|
215 | var e = _c.value;
|
216 | appendComment(e);
|
217 | }
|
218 | }
|
219 | catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
220 | finally {
|
221 | try {
|
222 | if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
223 | }
|
224 | finally { if (e_3) throw e_3.error; }
|
225 | }
|
226 | }
|
227 | }
|
228 | }
|
229 | return comments;
|
230 | }
|
231 | function addOptionalInformation(node, schema, terminate) {
|
232 | var format = schema.content.format;
|
233 | var pattern = schema.content.pattern;
|
234 | if (!format && !pattern) {
|
235 | return node;
|
236 | }
|
237 | var comment = '';
|
238 | if (format) {
|
239 | comment += ' ' + format;
|
240 | }
|
241 | if (pattern) {
|
242 | comment += ' ' + pattern;
|
243 | }
|
244 | if (!terminate) {
|
245 | comment += ' ';
|
246 | }
|
247 | var kind = terminate ? ts.SyntaxKind.SingleLineCommentTrivia : ts.SyntaxKind.MultiLineCommentTrivia;
|
248 | return ts.addSyntheticTrailingComment(node, kind, comment, false);
|
249 | }
|
250 | exports.addOptionalInformation = addOptionalInformation;
|
251 | function getLastTypeName(id) {
|
252 | var names = id.toNames();
|
253 | if (names.length > 0) {
|
254 | return names[names.length - 1];
|
255 | }
|
256 | else {
|
257 | return '';
|
258 | }
|
259 | }
|
260 |
|
\ | No newline at end of file |