Function schemaToType

src/JSONSchemaInput.ts:196–428

(typeBuilder: TypeGraphBuilder, topLevelName: string, rootJson: any)

}

export function schemaToType(typeBuilder: TypeGraphBuilder, topLevelName: string, rootJson: any): TypeRef {
    const root = checkStringMap(rootJson);
    let typeForPath = Map<List<any>, TypeRef>();

    function setTypeForPath(path: Ref, t: TypeRef): void {
        typeForPath = typeForPath.set(makeImmutablePath(path), t);
    }

    function unifyTypes(typesToUnify: TypeRef[], typeName: string, isInferred: boolean): TypeRef {
        if (typesToUnify.length === 0) {
            return panic("Cannot unify empty list of types");
        } else if (typesToUnify.length === 1) {
            return typesToUnify[0];
        } else {
            const unionBuilder = new UnifyUnionBuilder(typeBuilder, typeName, isInferred, unifyTypes);

            const registerType = (t: Type): void => {
                matchTypeExhaustive<void>(
                    t,
                    _anyType => unionBuilder.addAny(),
                    _nullType => unionBuilder.addNull(),
                    _boolType => unionBuilder.addBool(),
                    _integerType => unionBuilder.addInteger(),
                    _doubleType => unionBuilder.addDouble(),
                    _stringType => unionBuilder.addStringType("string"),
                    arrayType => unionBuilder.addArray(arrayType.items.typeRef),
                    classType => unionBuilder.addClass(classType.typeRef),
                    mapType => unionBuilder.addMap(mapType.values.typeRef),
                    enumType => enumType.cases.forEach(s => unionBuilder.addEnumCase(s)),
                    unionType => unionType.members.forEach(registerType),
                    _dateType => unionBuilder.addStringType("date"),
                    _timeType => unionBuilder.addStringType("time"),
                    _dateTimeType => unionBuilder.addStringType("date-time")
                );
            };

            for (const t of typesToUnify) {
                registerType(getHopefullyFinishedType(typeBuilder, t));
            }

            return unionBuilder.buildUnion(false);
        }
    }

    function lookupRef(local: StringMap, localPath: Ref, ref: Ref): [StringMap, Ref] {
        const first = ref.first();
        if (first === undefined) {
            return [local, localPath];
        }
        const rest = ref.rest();
        if (first.kind === PathElementKind.Root) {
            return lookupRef(root, List([first]), ref.rest());
        }
        localPath = localPath.push(first);
        switch (first.kind) {
            case PathElementKind.Definition:
                return lookupRef(lookupDefinition(local, first.name), localPath, rest);
            case PathElementKind.OneOf: