json-schema-typescript-generator/dist/cjs/schema/parser.js

Generate typescript types from json schemas

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parse = void 0;
const Schema_1 = require("./Schema");
const ids_1 = require("../ids");
const parse = (files) => {
    const schemas = new Map();
    files.forEach((content, fileLocation) => {
        const rawSchema = JSON.parse(content);
        const schema = parseSchema(rawSchema);
        schemas.set(fileLocation, schema);
    });
    return schemas;
};
exports.parse = parse;
const parseSchema = (rawSchema) => {
    const $id = (0, ids_1.parseSchemaId)(rawSchema.$id);
    const type = parseType(rawSchema.type);
    const $ref = (0, ids_1.parseSchemaRef)(rawSchema.$ref);
    const _enum = parseEnum(rawSchema.enum);
    const object = parseObject(rawSchema);
    const collection = parseCollection(rawSchema);
    const allOf = parseArray(rawSchema.allOf);
    const anyOf = parseArray(rawSchema.anyOf);
    const oneOf = parseArray(rawSchema.oneOf);
    const defs = parseRecord(rawSchema.$defs);
    const definitions = parseRecord(rawSchema.definitions);
    if (defs && definitions) {
        defs?.forEach((schema, key) => {
            definitions?.set(key, schema);
        });
    }
    return {
        $id,
        type,
        $ref,
        enum: _enum,
        object,
        collection,
        allOf,
        anyOf,
        oneOf,
        definitions: definitions ? definitions : defs,
    };
};
const parseType = (type) => {
    if (!type) {
        return;
    }
    const typeArray = (typeof type === 'string')
        ? [type]
        : type;
    return new Set(typeArray.filter(Schema_1.isBasicType));
};
const parseEnum = (_enum) => _enum
    ? new Set(_enum)
    : undefined;
const parseObject = (rawSchema) => {
    const properties = parseRecord(rawSchema.properties);
    const additionalProperties = parseAdditional(rawSchema.additionalProperties);
    const required = parseRequired(rawSchema.required);
    return (properties)
        ? {
            properties,
            additionalProperties,
            required
        }
        : undefined;
};
const parseCollection = (rawSchema) => {
    const items = parseItems(rawSchema.items);
    const additionalItems = parseAdditional(rawSchema.additionalItems);
    const uniqueItems = rawSchema.uniqueItems;
    return (items)
        ? {
            items,
            additionalItems,
            uniqueItems
        }
        : undefined;
};
const parseItems = (items) => {
    if (!items) {
        return;
    }
    if (Array.isArray(items)) {
        return items.map(parseSchema);
    }
    return parseSchema(items);
};
const parseAdditional = (additional) => additional
    ? parseSchema(additional)
    : undefined;
const parseArray = (array) => array
    ? array.map(parseSchema)
    : undefined;
const parseRecord = (record) => {
    if (!record) {
        return;
    }
    const parsed = new Map();
    for (const key in record) {
        const rawSchema = record[key];
        const schema = parseSchema(rawSchema);
        parsed.set(key, schema);
    }
    return parsed;
};
const parseRequired = (required) => new Set(required || []);
//# sourceMappingURL=parser.js.map