Merge branch 'development'

* development: (939 commits)
  Add asset-buyer to published packages section in README
  Publish
  Updated CHANGELOGS
  Update BuyQuote interface
  force re-build
  Add website build to instructions
  Revert format and re-add changes
  Build website in parallel with other tests since no other test relies on it being built to run
  Add back sourceMap support for both dev/prod
  Upgrade webpack
  Add missing default options
  Remove unused constants
  Add fee order with a takerFee
  Add additional order factory methods and refactor test to use them
  Add comments about buy quote calculation
  Update CHANGELOG
  Fix linter
  Add additional test for slippage
  Add buy_quote_calculator_test
  Add 0x Instant to bundle analysis
  ...

1 files changed, 31 insertions, 64 deletions

diff --git a/packages/react-docs/src/docs_info.ts b/packages/react-docs/src/docs_info.ts
index b37942da6..092a8c266 100644
--- a/packages/react-docs/src/docs_info.ts
+++ b/packages/react-docs/src/docs_info.ts
@@ -1,77 +1,38 @@
 import { MenuSubsectionsBySection } from '@0xproject/react-shared';
-import compareVersions = require('compare-versions');
+import { DocAgnosticFormat, TypeDefinitionByName } from '@0xproject/types';
 import * as _ from 'lodash';
 
 import {
     ContractsByVersionByNetworkId,
-    DocAgnosticFormat,
     DocsInfoConfig,
-    DocsInfoTypeConfigs,
     DocsMenu,
-    DoxityDocObj,
     SectionNameToMarkdownByVersion,
     SectionsMap,
     SupportedDocJson,
-    TypeDefinitionByName,
-    TypeDocNode,
 } from './types';
-import { doxityUtils } from './utils/doxity_utils';
-import { typeDocUtils } from './utils/typedoc_utils';
 
 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;
-    public typeConfigs: DocsInfoTypeConfigs;
-    private readonly _docsInfo: DocsInfoConfig;
     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.sections = config.sections;
+        this.typeSectionName = config.type === SupportedDocJson.SolDoc ? 'structs' : 'types';
+        this.sections = config.markdownSections;
         this.sectionNameToMarkdownByVersion = config.sectionNameToMarkdownByVersion;
         this.contractsByVersionByNetworkId = config.contractsByVersionByNetworkId;
-        this.typeConfigs = config.typeConfigs;
-        this._docsInfo = config;
-    }
-    public isPublicType(typeName: string): boolean {
-        if (_.isUndefined(this._docsInfo.typeConfigs.publicTypes)) {
-            return false;
-        }
-        const isPublic = _.includes(this._docsInfo.typeConfigs.publicTypes, typeName);
-        return isPublic;
-    }
-    public getModulePathsIfExists(sectionName: string): string[] {
-        const modulePathsIfExists = this._docsInfo.sectionNameToModulePath[sectionName];
-        return modulePathsIfExists;
-    }
-    public getMenu(selectedVersion?: string): { [section: string]: string[] } {
-        if (_.isUndefined(selectedVersion) || _.isUndefined(this._docsInfo.menuSubsectionToVersionWhenIntroduced)) {
-            return this._docsInfo.menu;
-        }
-
-        const finalMenu = _.cloneDeep(this._docsInfo.menu);
-        if (_.isUndefined(finalMenu.contracts)) {
-            return finalMenu;
-        }
-
-        // TODO: refactor to include more sections then simply the `contracts` section
-        finalMenu.contracts = _.filter(finalMenu.contracts, (contractName: string) => {
-            const versionIntroducedIfExists = this._docsInfo.menuSubsectionToVersionWhenIntroduced[contractName];
-            if (!_.isUndefined(versionIntroducedIfExists)) {
-                const doesExistInSelectedVersion = compareVersions(selectedVersion, versionIntroducedIfExists) >= 0;
-                return doesExistInSelectedVersion;
-            } else {
-                return true;
-            }
-        });
-        return finalMenu;
     }
     public getMenuSubsectionsBySection(docAgnosticFormat?: DocAgnosticFormat): MenuSubsectionsBySection {
         const menuSubsectionsBySection = {} as MenuSubsectionsBySection;
@@ -86,43 +47,49 @@ export class DocsInfo {
                 return; // no-op
             }
 
-            if (!_.isUndefined(this.sections.types) && sectionName === this.sections.types) {
+            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);
                 menuSubsectionsBySection[sectionName] = typeNames;
+            } 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 sortedMethodNames = _.sortBy(docSection.methods, 'name');
-                const methodNames = _.map(sortedMethodNames, m => m.name);
-                menuSubsectionsBySection[sectionName] = [...methodNames, ...eventNames];
+                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);
-                menuSubsectionsBySection[sectionName] = [...eventNames, ...functionNames, ...methodNames];
+                menuSubsectionsBySection[sectionName] = [
+                    ...eventNames,
+                    ...propertyNames,
+                    ...functionNames,
+                    ...methodNames,
+                ];
             }
         });
         return menuSubsectionsBySection;
     }
     public getTypeDefinitionsByName(docAgnosticFormat: DocAgnosticFormat): { [name: string]: TypeDefinitionByName } {
-        if (_.isUndefined(this.sections.types)) {
+        if (_.isUndefined(docAgnosticFormat[this.typeSectionName])) {
             return {};
         }
 
-        const typeDocSection = docAgnosticFormat[this.sections.types];
-        const typeDefinitionByName = _.keyBy(typeDocSection.types, 'name') as any;
+        const section = docAgnosticFormat[this.typeSectionName];
+        const typeDefinitionByName = _.keyBy(section.types, 'name') as any;
         return typeDefinitionByName;
     }
-    public isVisibleConstructor(sectionName: string): boolean {
-        return _.includes(this._docsInfo.visibleConstructors, sectionName);
-    }
-    public convertToDocAgnosticFormat(docObj: DoxityDocObj | TypeDocNode): DocAgnosticFormat {
-        if (this.type === SupportedDocJson.Doxity) {
-            return doxityUtils.convertToDocAgnosticFormat(docObj as DoxityDocObj);
-        } else {
-            return typeDocUtils.convertToDocAgnosticFormat(docObj as TypeDocNode, this);
-        }
-    }
 }