1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
import { ALink, utils as sharedUtils } from '@0xproject/react-shared';
import { DocAgnosticFormat, ObjectMap, TypeDefinitionByName } from '@0xproject/types';
import * as _ from 'lodash';
import {
ContractsByVersionByNetworkId,
DocsInfoConfig,
DocsMenu,
SectionNameToMarkdownByVersion,
SectionsMap,
SupportedDocJson,
} from './types';
export class DocsInfo {
public id: string;
public type: SupportedDocJson;
public displayName: string;
public packageName: string;
public packageUrl: string;
public menu: DocsMenu;
public typeSectionName: string;
public sections: SectionsMap;
public sectionNameToMarkdownByVersion: SectionNameToMarkdownByVersion;
public contractsByVersionByNetworkId?: ContractsByVersionByNetworkId;
constructor(config: DocsInfoConfig) {
this.id = config.id;
this.type = config.type;
this.menu = config.markdownMenu;
this.displayName = config.displayName;
this.packageName = config.packageName;
this.packageUrl = config.packageUrl;
this.typeSectionName = config.type === SupportedDocJson.SolDoc ? 'structs' : 'types';
this.sections = config.markdownSections;
this.sectionNameToMarkdownByVersion = config.sectionNameToMarkdownByVersion;
this.contractsByVersionByNetworkId = config.contractsByVersionByNetworkId;
}
public getSubsectionNameToLinks(docAgnosticFormat?: DocAgnosticFormat): ObjectMap<ALink[]> {
const subsectionNameToLinks: ObjectMap<ALink[]> = {};
if (_.isUndefined(docAgnosticFormat)) {
return subsectionNameToLinks;
}
const docSections = _.keys(this.sections);
_.each(docSections, sectionName => {
const docSection = docAgnosticFormat[sectionName];
if (_.isUndefined(docSection)) {
return; // no-op
}
const isExportedFunctionSection =
docSection.functions.length === 1 &&
_.isEmpty(docSection.types) &&
_.isEmpty(docSection.methods) &&
_.isEmpty(docSection.constructors) &&
_.isEmpty(docSection.properties) &&
_.isEmpty(docSection.events);
if (sectionName === this.typeSectionName) {
const sortedTypesNames = _.sortBy(docSection.types, 'name');
const typeNames = _.map(sortedTypesNames, t => t.name);
const typeLinks = _.map(typeNames, typeName => {
return {
to: `${sectionName}-${typeName}`,
title: typeName,
};
});
subsectionNameToLinks[sectionName] = typeLinks;
} else if (isExportedFunctionSection) {
// Noop so that we don't have the method listed underneath itself.
} else {
let eventNames: string[] = [];
if (!_.isUndefined(docSection.events)) {
const sortedEventNames = _.sortBy(docSection.events, 'name');
eventNames = _.map(sortedEventNames, m => m.name);
}
const propertiesSortedByName = _.sortBy(docSection.properties, 'name');
const propertyNames = _.map(propertiesSortedByName, m => m.name);
const methodsSortedByName = _.sortBy(docSection.methods, 'name');
const methodNames = _.map(methodsSortedByName, m => m.name);
const sortedFunctionNames = _.sortBy(docSection.functions, 'name');
const functionNames = _.map(sortedFunctionNames, m => m.name);
const names = [...eventNames, ...propertyNames, ...functionNames, ...methodNames];
const links = _.map(names, name => {
return {
to: `${sectionName}-${name}`,
title: name,
};
});
subsectionNameToLinks[sectionName] = links;
}
});
return subsectionNameToLinks;
}
public getTypeDefinitionsByName(docAgnosticFormat: DocAgnosticFormat): { [name: string]: TypeDefinitionByName } {
if (_.isUndefined(docAgnosticFormat[this.typeSectionName])) {
return {};
}
const section = docAgnosticFormat[this.typeSectionName];
const typeDefinitionByName = _.keyBy(section.types, 'name') as any;
return typeDefinitionByName;
}
public getSectionNameToLinks(): ObjectMap<ALink[]> {
const sectionNameToLinks: ObjectMap<ALink[]> = {};
_.each(this.menu, (linkTitles, sectionName) => {
sectionNameToLinks[sectionName] = [];
_.each(linkTitles, linkTitle => {
const to = sharedUtils.getIdFromName(linkTitle);
const links = sectionNameToLinks[sectionName];
links.push({
title: linkTitle,
to,
});
});
});
return sectionNameToLinks;
}
}
|
