api-middleware.js

import doc from './json/doc.json'
import examples from './json/examples.json'

class Data {

    constructor (doc, examples) {
        this.blocks = {}
        this.levels = []
        this.groups = ['all']
        this.blockNameToTypeName = {}
        this.typeNameToBlockName = {}
        this.blockNamesByLevelAndGroup = {}

        // Sort doc.blocks by name
        doc.blocks = doc.blocks.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)

        // Fill this.blocks
        for (let block of doc.blocks) {
            if (this.blocks[block.name] === undefined) {
                this.blocks[block.name] = {}
                this.blockNameToTypeName[block.name] = block.typeName
                this.typeNameToBlockName[block.typeName] = block.name
            }
            if (this.levels.indexOf(block.level) === -1) {
                this.levels.push(block.level)
            }
        }

        for (let level of this.levels) {
            this.blockNamesByLevelAndGroup[level] = {}
            for (let group of this.groups) {
                this.blockNamesByLevelAndGroup[level][group] = []
            }
        }

        // Assign types to this.blocks
        let extractTypeData = (type) => {
            if (type === undefined) {
                return {
                    isArray: false,
                    isBlock: false,
                    typeName: 'unknown',
                }
            }

            let isBlock = ['object', 'number', 'string', 'boolean'].indexOf(type.name.toLowerCase()) === -1
            return {
                isArray: type.isArray ? true : false,
                isBlock: isBlock,
                typeName: isBlock ? type.name : type.name.toLowerCase(),
            }
        }
        for (let blockName in this.blocks) {
            for (let level of this.levels) {
                let typeName = this.blockNameToTypeName[blockName]
                let type

                for (let t of doc.types) {
                    if (t.name === typeName && t.level === level) {
                        type = t
                        break
                    }
                }

                if (type !== undefined) {
                    let block = this.blocks[blockName][level] = {
                        name: blockName,
                        typeName: this.blockNameToTypeName[blockName],
                        level: level,
                        description: type.description,
                        codePath: type.codePath,
                    }

                    if (type.properties && type.properties.length) {
                        block.properties = type.properties
                            .map(prop => {
                                let property = {
                                    name: prop.name,
                                    required: prop.required ? true : false,
                                }

                                if (prop.mixinName) {
                                    property.mixin = prop.mixinName
                                }

                                if (prop.description) {
                                    property.description = prop.description
                                }

                                if (prop.values && prop.values.length) {
                                    property.values = prop.values
                                }

                                if (prop.defaultValue) {
                                    property.defaultValue = prop.defaultValue
                                }

                                if (prop.typeName && prop.typeName.length) {
                                    property.types = []
                                    for (let typeName of prop.typeName) {
                                        property.types.push(
                                            extractTypeData(typeName)
                                        )
                                    }
                                } else {
                                    property.types = [extractTypeData()]
                                }

                                return property
                            })
                            .sort(function (a, b) {
                                return a.name < b.name ? -1 : a.name > b.name ? 1 : 0
                            })
                    }

                    if (type.typeName && type.typeName.length) {
                        block.types = []
                        for (let typeName of type.typeName) {
                            block.types.push(
                                extractTypeData(typeName)
                            )
                        }
                    }

                    for (let group of this.groups) {
                        if (group === 'all' || (block.groups && block.groups.indexOf(group) !== -1)) {
                            this.blockNamesByLevelAndGroup[level][group].push(blockName)
                        }
                    }
                }
            }
        }

        // Assign examples to this.blocks
        for (let example of examples) {
            if (this.blocks[example.name] !== undefined) {
                for (let level in this.blocks[example.name]) {
                    let block = this.blocks[example.name][level]
                    if (block.examples === undefined) {
                        block.examples = []
                    }

                    let exampleItem = {}
                    if (example.item) {
                        exampleItem.name = example.item
                    }
                    exampleItem.foreverId = []
                    if (example.links.group && example.links.group.indexOf('http') === -1) {
                        exampleItem.foreverId = example.links.group.split(', ')
                    }
                    exampleItem.foreverId.push(example.links.forever)

                    block.examples.push(exampleItem)
                }
            }
        }
    }

    getBlock ({level, blockName, blockIndex, typeName, groupName, groupIndex}) {
        if (groupName === undefined && blockName === undefined) {
            groupName = groupIndex === undefined ? 'all' : this.groups[groupIndex]
        }

        if (blockIndex !== undefined) {
            blockName = this.blockNamesByLevelAndGroup[level][groupName][blockIndex]
        }

        if (typeName !== undefined) {
            blockName = this.typeNameToBlockName[typeName]
        }

        if (this.blocks[blockName] === undefined) {
            return undefined
        }

        return this.blocks[blockName][level]
    }

    getBlockNamesByGroup ({level}) {
        return this.blockNamesByLevelAndGroup[level]
    }

    getGroupName ({groupIndex}) {
        return this.groups[groupIndex]
    }

    getBlockName ({level, groupName, blockIndex}) {
        return this.blockNamesByLevelAndGroup[level][groupName][blockIndex]
    }
}

export default new Data(doc, examples)

/*
block:
    name:
    typeName:
    description:
    level:
    types: [
        isArray:
        isBlock:
        typeName:
    ]
    properties: [
        description:
        name:
        required:
        types: [
            isArray:
            isBlock:
            typeName:
        ]
        values: []
        defaultValue:
    ]
*/