json-schema-typescript-generator/dist/cjs/generate/file-generator.js

Generate typescript types from json schemas

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.fileGenerator = void 0;
const path = __importStar(require("path"));
const util_1 = require("../util");
const OneOfN_generator_1 = require("./OneOfN-generator");
const name_generator_1 = require("./name-generator");
const type_generator_1 = require("./type-generator");
const fileGenerator = (locatedSchema, inputInfo) => {
    const references = {
        schema: new Map()
    };
    const gatheredInfo = {
        namedSchemas: new Map(),
        references,
        oneOfTypes: new Set()
    };
    const schemaContent = schemaContentGenerator(locatedSchema, gatheredInfo, inputInfo);
    const definitions = schemaMapGenerator(locatedSchema.fileLocation, locatedSchema.schema.definitions, gatheredInfo, inputInfo);
    const named = namedGenerator(locatedSchema.fileLocation, gatheredInfo, inputInfo);
    const imports = importsGenerator(locatedSchema.fileLocation, references);
    const oneOfs = oneOfTypesGenerator(gatheredInfo.oneOfTypes);
    return (0, util_1.filteredJoin)([imports, schemaContent, named, definitions, oneOfs], '\n\n') + '\n';
};
exports.fileGenerator = fileGenerator;
const schemaContentGenerator = (locatedSchema, gatheredInfo, inputInfo, schemaName) => {
    const typeName = (0, name_generator_1.nameGenerator)(schemaName || locatedSchema.fileLocation.fileName);
    const typeContent = (0, type_generator_1.typeGenerator)(locatedSchema, gatheredInfo, inputInfo);
    return typeContent
        ? `export type ${typeName} = ${typeContent};`
        : undefined;
};
const importsGenerator = (fileLocation, references) => {
    if (references.schema.size === 0) {
        return;
    }
    const content = [];
    content.push(importMapGenerator(fileLocation, references.schema));
    const defined = (0, util_1.filtered)(content);
    return defined.join('\n');
};
const importMapGenerator = (fileLocation, references) => {
    if (references.size === 0) {
        return;
    }
    const imports = [];
    references.forEach((names, referenceFileLocation) => {
        if (names.size > 0) {
            const combinedNames = Array.from(names).sort().join(', ');
            const importPath = tsPathGenerator(path.normalize(path.relative(fileLocation.dir, referenceFileLocation.dir)));
            const file = referenceFileLocation.fileName.length === 0 ? '' : `/${referenceFileLocation.fileName}`;
            imports.push(`import { ${combinedNames} } from '${importPath}${file}';`);
        }
    });
    return imports.join('\n');
};
const namedGenerator = (fileLocation, gatheredInfo, inputInfo) => {
    if (gatheredInfo.namedSchemas.size === 0) {
        return;
    }
    const content = [];
    while (true) {
        const map = gatheredInfo.namedSchemas;
        gatheredInfo = {
            ...gatheredInfo,
            namedSchemas: new Map()
        };
        const schemaMapContent = schemaMapGenerator(fileLocation, map, gatheredInfo, inputInfo);
        if (schemaMapContent) {
            content.push(schemaMapContent);
        }
        else {
            return content.length === 0
                ? undefined
                : content.join('\n');
        }
    }
};
const oneOfTypesGenerator = (typeCounts) => {
    if (typeCounts.size === 0) {
        return;
    }
    const oneOfTypeLines = [];
    typeCounts.forEach((typeCount) => {
        const oneOfType = (0, OneOfN_generator_1.OneOfNGenerator)(typeCount);
        if (oneOfType) {
            oneOfTypeLines.push(oneOfType);
        }
    });
    return oneOfTypeLines.join('\n');
};
const schemaMapGenerator = (fileLocation, map, gatheredInfo, inputInfo) => {
    if (!map || map.size === 0) {
        return;
    }
    const content = [];
    map.forEach((namedSchema, name) => {
        const namedLocatedSchema = {
            fileLocation,
            schema: namedSchema
        };
        const schemaContent = schemaContentGenerator(namedLocatedSchema, gatheredInfo, inputInfo, name);
        if (schemaContent) {
            content.push(schemaContent);
        }
    });
    return content.join('\n');
};
const tsPathGenerator = (relativePath) => relativePath.startsWith('.')
    ? relativePath
    : '.' + path.sep + relativePath;
//# sourceMappingURL=file-generator.js.map