1 | "use strict";
|
2 |
|
3 |
|
4 | var __importDefault = (this && this.__importDefault) || function (mod) {
|
5 | return (mod && mod.__esModule) ? mod : { "default": mod };
|
6 | };
|
7 | Object.defineProperty(exports, "__esModule", { value: true });
|
8 | exports.convertUDPYamlToSDP = void 0;
|
9 | const path_1 = __importDefault(require("path"));
|
10 | const node_core_library_1 = require("@rushstack/node-core-library");
|
11 | const yaml = require("js-yaml");
|
12 | function convertUDPYamlToSDP(folderPath) {
|
13 | convert(folderPath, folderPath);
|
14 | }
|
15 | exports.convertUDPYamlToSDP = convertUDPYamlToSDP;
|
16 | function convert(inputPath, outputPath) {
|
17 | console.log();
|
18 | if (!node_core_library_1.FileSystem.exists(inputPath)) {
|
19 | console.error(`input path: ${inputPath} is not exist`);
|
20 | return;
|
21 | }
|
22 | node_core_library_1.FileSystem.readFolderItemNames(inputPath).forEach((name) => {
|
23 | const fpath = path_1.default.join(inputPath, name);
|
24 | if (node_core_library_1.FileSystem.getStatistics(fpath).isFile()) {
|
25 |
|
26 | if (!name.endsWith('.yml')) {
|
27 | return;
|
28 | }
|
29 |
|
30 | const yamlContent = node_core_library_1.FileSystem.readFile(fpath, { encoding: node_core_library_1.Encoding.Utf8 });
|
31 |
|
32 | const isLegacyYaml = yamlContent.startsWith('### YamlMime:UniversalReference');
|
33 | if (!isLegacyYaml) {
|
34 | return;
|
35 | }
|
36 | console.log(`convert file ${fpath} from udp to sdp`);
|
37 | const file = yaml.safeLoad(yamlContent);
|
38 | const result = convertToSDP(file);
|
39 | if (result && result.model) {
|
40 | const stringified = `### YamlMime:TS${result.type}\n${yaml.safeDump(result.model, {
|
41 | lineWidth: 120
|
42 | })}`;
|
43 | node_core_library_1.FileSystem.writeFile(`${outputPath}/${name}`, stringified, {
|
44 | convertLineEndings: node_core_library_1.NewlineKind.CrLf,
|
45 | ensureFolderExists: true
|
46 | });
|
47 | }
|
48 | else {
|
49 | console.log('not target file ', fpath);
|
50 | }
|
51 | }
|
52 | else {
|
53 |
|
54 | convert(fpath, path_1.default.join(outputPath, name));
|
55 | }
|
56 | });
|
57 | }
|
58 | function convertToPackageSDP(transfomredClass) {
|
59 | const element = transfomredClass.items[0];
|
60 | const packageModel = {
|
61 | uid: element.uid,
|
62 | name: element.name,
|
63 | type: 'package'
|
64 | };
|
65 | if (element.summary) {
|
66 | packageModel.summary = element.summary;
|
67 | }
|
68 | else {
|
69 | packageModel.summary = '';
|
70 | }
|
71 |
|
72 | if (element.children) {
|
73 | element.children.forEach((child) => {
|
74 | if (child.endsWith(':class')) {
|
75 | assignPackageModelFields(packageModel, 'classes', child);
|
76 | }
|
77 | else if (child.endsWith(':interface')) {
|
78 | assignPackageModelFields(packageModel, 'interfaces', child);
|
79 | }
|
80 | else if (child.endsWith(':enum')) {
|
81 | assignPackageModelFields(packageModel, 'enums', child);
|
82 | }
|
83 | else if (child.endsWith(':type')) {
|
84 | assignPackageModelFields(packageModel, 'typeAliases', child);
|
85 | }
|
86 | else {
|
87 |
|
88 | }
|
89 | });
|
90 | }
|
91 | for (let i = 1; i < transfomredClass.items.length; i++) {
|
92 | const ele = transfomredClass.items[i];
|
93 | switch (ele.type) {
|
94 | case 'typealias':
|
95 |
|
96 | break;
|
97 | case 'function':
|
98 | if (!packageModel.functions) {
|
99 | packageModel.functions = [];
|
100 | }
|
101 | packageModel.functions.push(convertToFunctionSDP(ele, element.uid, transfomredClass));
|
102 | break;
|
103 | default:
|
104 |
|
105 | console.log('[warning] not applied type(package): ', ele.type);
|
106 | }
|
107 | }
|
108 | return packageModel;
|
109 | }
|
110 | function assignPackageModelFields(packageModel, name, uid) {
|
111 | if (!packageModel[name]) {
|
112 | packageModel[name] = [];
|
113 | }
|
114 | packageModel[name].push(uid);
|
115 | }
|
116 | function convertToSDP(transfomredClass) {
|
117 | const element = transfomredClass.items[0];
|
118 | switch (element.type) {
|
119 | case 'class':
|
120 | case 'interface':
|
121 | return {
|
122 | model: convertToTypeSDP(transfomredClass, element.type === 'class'),
|
123 | type: 'Type'
|
124 | };
|
125 | case 'enum':
|
126 | if (transfomredClass.items.length < 2) {
|
127 | console.log(`[warning] enum ${element.uid}/${element.name} does not have fields`);
|
128 | return undefined;
|
129 | }
|
130 | return { model: convertToEnumSDP(transfomredClass), type: 'Enum' };
|
131 | case 'typealias':
|
132 | return { model: convertToTypeAliasSDP(element, transfomredClass), type: 'TypeAlias' };
|
133 | case 'package':
|
134 | return {
|
135 | model: convertToPackageSDP(transfomredClass),
|
136 | type: 'Package'
|
137 | };
|
138 | default:
|
139 | console.log('not applied type: ', element.type);
|
140 | return undefined;
|
141 | }
|
142 | }
|
143 | function convertToEnumSDP(transfomredClass) {
|
144 | const element = transfomredClass.items[0];
|
145 | const fields = [];
|
146 | for (let i = 1; i < transfomredClass.items.length; i++) {
|
147 | const ele = transfomredClass.items[i];
|
148 | const field = {
|
149 | name: ele.name,
|
150 | uid: ele.uid,
|
151 | package: element.package
|
152 | };
|
153 | if (ele.summary) {
|
154 | field.summary = ele.summary;
|
155 | }
|
156 | else {
|
157 | field.summary = '';
|
158 | }
|
159 | if (ele.numericValue) {
|
160 | field.value = ele.numericValue;
|
161 | }
|
162 | fields.push(field);
|
163 | }
|
164 | const result = Object.assign(Object.assign({}, convertCommonYamlModel(element, element.package, transfomredClass)), { fields: fields });
|
165 | return result;
|
166 | }
|
167 | function convertToTypeAliasSDP(element, transfomredClass) {
|
168 | const result = Object.assign({}, convertCommonYamlModel(element, element.package, transfomredClass));
|
169 | if (element.syntax) {
|
170 | result.syntax = element.syntax.content;
|
171 | }
|
172 | return result;
|
173 | }
|
174 | function convertToTypeSDP(transfomredClass, isClass) {
|
175 | const element = transfomredClass.items[0];
|
176 | const constructors = [];
|
177 | const properties = [];
|
178 | const methods = [];
|
179 | const events = [];
|
180 | for (let i = 1; i < transfomredClass.items.length; i++) {
|
181 | const ele = transfomredClass.items[i];
|
182 | const item = convertCommonYamlModel(ele, element.package, transfomredClass);
|
183 | if (ele.type === 'constructor') {
|
184 |
|
185 | if (isClass) {
|
186 | constructors.push(item);
|
187 | }
|
188 | }
|
189 | else if (ele.type === 'property') {
|
190 | properties.push(item);
|
191 | }
|
192 | else if (ele.type === 'method') {
|
193 | methods.push(item);
|
194 | }
|
195 | else if (ele.type === 'event') {
|
196 | events.push(item);
|
197 | }
|
198 | else {
|
199 | console.log(`[warning] ${ele.uid}#${ele.name} is not applied sub type ${ele.type} for type yaml`);
|
200 | }
|
201 | }
|
202 | const result = Object.assign(Object.assign({}, convertCommonYamlModel(element, element.package, transfomredClass)), { type: isClass ? 'class' : 'interface' });
|
203 | delete result.syntax;
|
204 | if (constructors.length > 0) {
|
205 | result.constructors = constructors;
|
206 | }
|
207 | if (properties.length > 0) {
|
208 | result.properties = properties;
|
209 | }
|
210 | if (methods.length > 0) {
|
211 | result.methods = methods;
|
212 | }
|
213 | if (events.length > 0) {
|
214 | result.events = events;
|
215 | }
|
216 | if (element.extends && element.extends.length > 0) {
|
217 | result.extends = convertSelfTypeToXref(element.extends[0], transfomredClass);
|
218 | }
|
219 | return result;
|
220 | }
|
221 | function convertToFunctionSDP(element, packageName, transfomredClass) {
|
222 | const model = convertCommonYamlModel(element, packageName, transfomredClass);
|
223 |
|
224 | delete model.fullName;
|
225 | return model;
|
226 | }
|
227 | function convertCommonYamlModel(element, packageName, transfomredClass) {
|
228 | var _a;
|
229 | const result = {
|
230 | name: element.name,
|
231 | uid: element.uid,
|
232 | package: packageName
|
233 | };
|
234 | if (element.fullName) {
|
235 | result.fullName = element.fullName;
|
236 | }
|
237 | if (element.summary) {
|
238 | result.summary = element.summary;
|
239 | }
|
240 | else {
|
241 | result.summary = '';
|
242 | }
|
243 |
|
244 |
|
245 |
|
246 |
|
247 | if (element.remarks) {
|
248 | result.remarks = element.remarks;
|
249 | }
|
250 | else {
|
251 | result.remarks = '';
|
252 | }
|
253 | if (element.example) {
|
254 | result.example = element.example;
|
255 | }
|
256 | else {
|
257 | result.example = [];
|
258 | }
|
259 | result.isPreview = element.isPreview;
|
260 | if (!result.isPreview) {
|
261 | result.isPreview = false;
|
262 | }
|
263 | if (element.deprecated) {
|
264 | result.isDeprecated = true;
|
265 | result.customDeprecatedMessage = element.deprecated.content;
|
266 | }
|
267 | else {
|
268 | result.isDeprecated = false;
|
269 | }
|
270 | if (element.syntax) {
|
271 | result.syntax = {};
|
272 | const syntax = element.syntax;
|
273 | result.syntax.content = syntax.content;
|
274 | if (syntax.parameters && syntax.parameters.length > 0) {
|
275 | (_a = syntax.parameters) === null || _a === void 0 ? void 0 : _a.forEach((it) => {
|
276 | delete it.optional;
|
277 | delete it.defaultValue;
|
278 | });
|
279 | result.syntax.parameters = syntax.parameters.map((it) => {
|
280 | return Object.assign(Object.assign({}, it), { id: it.id, type: convertSelfTypeToXref(escapeMarkdown(it.type[0]), transfomredClass) });
|
281 | });
|
282 | }
|
283 | if (syntax.return) {
|
284 | result.syntax.return = Object.assign(Object.assign({}, syntax.return), { type: convertSelfTypeToXref(escapeMarkdown(syntax.return.type[0]), transfomredClass) });
|
285 | }
|
286 | }
|
287 | return result;
|
288 | }
|
289 | function escapeMarkdown(name) {
|
290 |
|
291 | const markdownLinkRegEx = /^\s*(\[.+\]):(.+)/g;
|
292 | return name.replace(markdownLinkRegEx, `$1\\:$2`);
|
293 | }
|
294 | function convertSelfTypeToXref(name, transfomredClass) {
|
295 | var _a, _b, _c;
|
296 | let result = name;
|
297 |
|
298 | if (result.endsWith(':complex')) {
|
299 | const specs = (_b = (_a = transfomredClass.references) === null || _a === void 0 ? void 0 : _a.find((item) => {
|
300 | return item.uid === name;
|
301 | })) === null || _b === void 0 ? void 0 : _b['spec.typeScript'];
|
302 | if (specs && specs.length > 0) {
|
303 | result = '';
|
304 | for (const spec of specs) {
|
305 |
|
306 | if (spec.uid && !spec.uid.startsWith('!')) {
|
307 | result += spec.uid;
|
308 | }
|
309 | else {
|
310 | result += spec.name;
|
311 | }
|
312 | }
|
313 | }
|
314 | }
|
315 | else if (result.startsWith('!')) {
|
316 |
|
317 |
|
318 |
|
319 | const ref = (_c = transfomredClass.references) === null || _c === void 0 ? void 0 : _c.find((item) => {
|
320 | return item.uid === name;
|
321 | });
|
322 | if (ref && ref.name) {
|
323 | result = ref.name;
|
324 | }
|
325 | }
|
326 |
|
327 | result = result.replace(/</g, '<').replace(/>/g, '>');
|
328 | const uidRegEx = /(@?[\w\d\-/!~\.]+\:[\w\d\-\(/]+)/g;
|
329 | return result.replace(uidRegEx, `<xref uid="$1" />`);
|
330 | }
|
331 |
|
\ | No newline at end of file |