typescript-interface-generator/dist/index.js

type generator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ts_simple_ast_1 = require("ts-simple-ast");
const utils_1 = require("./utils");
function fromNestedObject(objectName, value, file, createdInterfaces = [], parentName = '') {
    const { interface: createdInterface, interfaces } = createInterface(value, objectName, file, parentName, createdInterfaces);
    const { interfaces: newInterfaces, name } = utils_1.addOrRemoveInterface(createdInterface, interfaces);
    return {
        interfaces: newInterfaces,
        name,
    };
}
function collectTypesFromArray(array, arrayName, file, createdInterfaces = []) {
    if (array.length === 0) {
        return {
            types: ['any'],
            interfaces: createdInterfaces,
        };
    }
    const types = array
        .map(value => {
        if (Array.isArray(value)) {
            const { types, interfaces } = collectTypesFromArray(value, `${arrayName}A`, file, createdInterfaces);
            createdInterfaces = interfaces;
            return types;
        }
        else if (value === null) {
            return 'null';
        }
        else if (typeof value === 'object') {
            const typeName = createdInterfaces.length === 0
                ? utils_1.capitalize(arrayName)
                : utils_1.capitalize(`${arrayName}${createdInterfaces.length}`);
            const { name, interfaces } = fromNestedObject(typeName, value, file, createdInterfaces, typeName);
            createdInterfaces = interfaces;
            return name;
        }
        return typeof value;
    })
        .reduce((a, b) => a.concat(b), [])
        .reduce(utils_1.keepUniq, []);
    return {
        types,
        interfaces: createdInterfaces,
    };
}
function createInterface(object, objectName, file, parrentName = '', createdInterfaces = []) {
    const interfaceDeclaration = file.addInterface({
        name: objectName,
    });
    Object.keys(object).forEach(key => {
        const name = key;
        let typeName = typeof object[key];
        if (Array.isArray(object[key])) {
            const { types, interfaces } = collectTypesFromArray(object[key], key, file, createdInterfaces);
            typeName = utils_1.buildTypeStringOfArrayTypes(types);
            createdInterfaces = interfaces;
        }
        else if (object[key] === null) {
            typeName = 'null';
        }
        else if (typeof object[key] === 'object') {
            const keyName = utils_1.capitalize(key);
            typeName = `${parrentName ? parrentName : ''}${keyName}`;
            const { interfaces, name } = fromNestedObject(typeName, object[key], file, createdInterfaces, keyName);
            typeName = name;
            createdInterfaces = interfaces;
        }
        interfaceDeclaration.addProperty({
            name,
            type: typeName,
        });
    });
    return {
        interface: interfaceDeclaration,
        interfaces: createdInterfaces,
    };
}
function createInterfacesFromObject(objectName, object) {
    const fileName = 'file.ts';
    const project = new ts_simple_ast_1.Project({
        useVirtualFileSystem: true,
        manipulationSettings: { indentationText: ts_simple_ast_1.IndentationText.TwoSpaces },
    });
    const fs = project.getFileSystem();
    const file = project.createSourceFile(fileName, '');
    createInterface(object, objectName, file);
    file.saveSync();
    const content = fs.readFileSync(fileName);
    fs.delete(fileName);
    return content;
}
exports.createInterfacesFromObject = createInterfacesFromObject;