Function convertToType

src/JSONSchemaInput.ts:375–410

(schema: StringMap, path: Ref, name: string, isInferred: boolean)

    }

    function convertToType(schema: StringMap, path: Ref, name: string, isInferred: boolean): TypeRef {
        [name, isInferred] = getName(schema, name, isInferred);

        function convertOneOrAnyOf(cases: any, kind: PathElementKind.OneOf | PathElementKind.AnyOf): TypeRef {
            if (!Array.isArray(cases)) {
                return panic(`oneOf or anyOf is not an array: ${cases}`);
            }
            // FIXME: This cast shouldn't be necessary, but TypeScript forces our hand.
            const types = cases.map((t, index) =>
                toType(checkStringMap(t), path.push({ kind, index } as any), name, isInferred)
            );
            return unifyTypes(types, name, isInferred);
        }

        if (schema.$ref !== undefined) {
            const [ref, refName] = parseRef(schema.$ref);
            const [target, targetPath] = lookupRef(schema, path, ref);
            return toType(target, targetPath, isInferred ? refName : name, isInferred);
        } else if (schema.enum !== undefined) {
            return typeBuilder.getEnumType(name, isInferred, OrderedSet(checkStringArray(schema.enum)));
        } else if (schema.type !== undefined) {
            const typeNames = checkTypeList(schema.type);
            if (typeNames.size === 1) {
                return fromTypeName(schema, path, name, defined(typeNames.first()));
            } else {
                const types = typeNames.map(n => fromTypeName(schema, path, name, n));
                return unifyTypes(types.toArray(), name, isInferred);
            }
        } else if (schema.oneOf !== undefined) {
            return convertOneOrAnyOf(schema.oneOf, PathElementKind.OneOf);
        } else if (schema.anyOf !== undefined) {
            return convertOneOrAnyOf(schema.anyOf, PathElementKind.AnyOf);
        } else {
            return typeBuilder.getPrimitiveType("any");
        }
    }

    function toType(schema: StringMap, path: Ref, name: string, isInferred: boolean): TypeRef {
        // FIXME: This fromJS thing is ugly and inefficient.  Schemas aren't