roc/lib/documentation/generate-table.js

Build modern web applications easily

'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = generateTable;

var _deepExtend = require('deep-extend');

var _deepExtend2 = _interopRequireDefault(_deepExtend);

var _lodash = require('lodash');

var _stripAnsi = require('strip-ansi');

var _stripAnsi2 = _interopRequireDefault(_stripAnsi);

var _helpers = require('./helpers');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const defaultSettings = {
    groupTitleWrapper: name => name,
    cellDivider: '|',
    rowWrapper: input => `|${ input }|`,
    cellWrapper: input => ` ${ input } `,
    header: true,
    compact: false
};

/**
 * Creates a table based on a {@link rocDocumentationObject}.
 *
 * @param {rocDocumentationObject} initalDocumentationObject - The documentation object to create a table of.
 * @param {rocTableHeader} header - Header object to use.
 * @param {rocTableSettings} settings - The settings to use.
 *
 * @returns {string} - A table.
 */
function generateTable(initalDocumentationObject, header, settings) {
    settings = (0, _deepExtend2.default)({}, defaultSettings, settings);
    const headerLengths = createLengthObject(header, header, {}, true);
    const lengths = createLengthObject(initalDocumentationObject, header, headerLengths);

    const printTableCell = function printTableCell(key, element) {
        let renderer = arguments.length <= 2 || arguments[2] === undefined ? input => input || '' : arguments[2];
        let fill = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];
        let object = arguments[4];

        if (fill) {
            return settings.cellWrapper((0, _helpers.pad)(lengths[key], '-'));
        }
        const padding = (0, _lodash.isUndefined)(header[key].padding) ? true : header[key].padding;
        const text = padding ? (0, _helpers.addPadding)(renderer(element, object), lengths[key]) : renderer(element, object);

        return settings.cellWrapper(text);
    };

    const printTableRow = function printTableRow(object) {
        let isHeader = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

        return settings.rowWrapper(Object.keys(header).map(key => {
            var _getValueAndRenderer = getValueAndRenderer(isHeader, header[key], object[key]);

            const value = _getValueAndRenderer.value;
            const renderer = _getValueAndRenderer.renderer;


            return printTableCell(key, value, renderer, undefined, object);
        }).join(settings.cellDivider));
    };

    const printTableSplitter = () => {
        return settings.rowWrapper(Object.keys(header).map(key => printTableCell(key, undefined, undefined, true)).join(settings.cellDivider));
    };

    const printTableHead = function printTableHead(name, parentNames, description) {
        let level = arguments.length <= 3 || arguments[3] === undefined ? 0 : arguments[3];
        let printTableHeader = arguments.length <= 4 || arguments[4] === undefined ? true : arguments[4];

        const rows = [];
        rows.push(settings.groupTitleWrapper(name, level, parentNames));

        if (description) {
            rows.push(description);
        }

        if (settings.header && printTableHeader) {
            // Add a new empty row
            rows.push('');
            rows.push(printTableRow(header, true));
            rows.push(printTableSplitter());
        }

        return rows;
    };

    const recursiveHelper = function recursiveHelper() {
        let documentationObject = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
        let first = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

        const spacing = settings.compact || first ? [] : [''];

        return documentationObject.map(group => {
            let rows = [];
            const level = group.level || 0;
            const objects = group.objects || [];

            if (level === 0 || !settings.compact) {
                rows = rows.concat(printTableHead(group.name, group.parentNames, group.description, level, objects.length > 0));
            }

            rows = rows.concat(objects.map(element => printTableRow(element)));

            rows = rows.concat(recursiveHelper(group.children));

            if (group.level !== undefined && level === 0 && settings.compact) {
                rows.push('');
            }

            return rows;
        }).reduce((a, b) => a.concat(b), spacing);
    };

    return recursiveHelper(initalDocumentationObject, true).join('\n');
}

function createLengthObject(initalElements, header, initalLengths) {
    let isHeader = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];

    const getObjectLength = function getObjectLength(element) {
        let renderer = arguments.length <= 1 || arguments[1] === undefined ? input => input : arguments[1];
        let object = arguments[2];

        return (0, _stripAnsi2.default)(renderer(element, object)).length;
    };

    const getLength = function getLength(newLength) {
        let currentLength = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];

        return newLength > currentLength ? newLength : currentLength;
    };

    const recursiveHelper = function recursiveHelper() {
        let elements = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
        let lengths = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

        let newLengths = _extends({}, lengths);
        elements.forEach(element => {
            const objects = element.objects || [];
            objects.forEach(object => {
                Object.keys(header).forEach(key => {
                    var _getValueAndRenderer2 = getValueAndRenderer(isHeader, header[key], object[key]);

                    const value = _getValueAndRenderer2.value;
                    const renderer = _getValueAndRenderer2.renderer;

                    if (value !== undefined && value !== null) {
                        newLengths[key] = getLength(getObjectLength(value, renderer, object), newLengths[key]);
                    }
                });
            });

            newLengths = recursiveHelper(element.children, newLengths);
        });

        return newLengths;
    };

    // Make sure the data matches the expected format
    if (!Array.isArray(initalElements)) {
        initalElements = [{ objects: [initalElements], children: [] }];
    }

    return recursiveHelper(initalElements, initalLengths);
}

function getValueAndRenderer(isHeader, headerObject, object) {
    const value = isHeader ? object.name : object;
    const renderer = isHeader ? input => input : headerObject.renderer;

    return {
        value,
        renderer
    };
}
//# sourceMappingURL=generate-table.js.map