quicktype 18.0.5 → 19.0.4

package/dist/quicktype-core/language/ruby/keywords.js

@@ -1,358 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reservedProperties = exports.globals = exports.keywords = void 0;
-exports.keywords = [
-    "__ENCODING__",
-    "__FILE__",
-    "__LINE__",
-    "alias",
-    "and",
-    "begin",
-    "BEGIN",
-    "break",
-    "case",
-    "class",
-    "def",
-    "defined?",
-    "do",
-    "else",
-    "elsif",
-    "end",
-    "END",
-    "ensure",
-    "false",
-    "for",
-    "if",
-    "in",
-    "module",
-    "next",
-    "nil",
-    "not",
-    "or",
-    "redo",
-    "rescue",
-    "retry",
-    "return",
-    "self",
-    "super",
-    "then",
-    "true",
-    "undef",
-    "unless",
-    "until",
-    "when",
-    "while",
-    "yield"
-];
-const globalClasses = [
-    "ArgumentError",
-    "Array",
-    "BasicObject",
-    "Class",
-    "ClosedQueueError",
-    "Comparable",
-    "Complex",
-    "ConditionVariable",
-    "Continuation",
-    "Data",
-    "Date",
-    "Dir",
-    "ENV",
-    "EOFError",
-    "Encoding",
-    "EncodingError",
-    "Enumerable",
-    "Enumerator",
-    "Errno",
-    "Exception",
-    "FalseClass",
-    "Fiber",
-    "FiberError",
-    "File",
-    "FileTest",
-    "Float",
-    "FloatDomainError",
-    "FrozenError",
-    "GC",
-    "Hash",
-    "IO",
-    "IOError",
-    "IndexError",
-    "Integer",
-    "Interrupt",
-    "KeyError",
-    "LoadError",
-    "LocalJumpError",
-    "Marshal",
-    "MatchData",
-    "Math",
-    "Method",
-    "Module",
-    "Mutex",
-    "NameError",
-    "NilClass",
-    "NoMemoryError",
-    "NoMethodError",
-    "NotImplementedError",
-    "Numeric",
-    "Object",
-    "ObjectSpace",
-    "Proc",
-    "Process",
-    "Queue",
-    "Random",
-    "Range",
-    "RangeError",
-    "Rational",
-    "Regexp",
-    "RegexpError",
-    "RubyVM",
-    "RuntimeError",
-    "ScriptError",
-    "SecurityError",
-    "Set",
-    "Signal",
-    "SignalException",
-    "SizedQueue",
-    "StandardError",
-    "StopIteration",
-    "String",
-    "Struct",
-    "Symbol",
-    "SyntaxError",
-    "SystemCallError",
-    "SystemExit",
-    "SystemStackError",
-    "Thread",
-    "ThreadError",
-    "ThreadGroup",
-    "Time",
-    "TracePoint",
-    "TrueClass",
-    "TypeError",
-    "UnboundMethod",
-    "UncaughtThrowError",
-    "Undefined",
-    "UnicodeNormalize",
-    "Warning",
-    "ZeroDivisionError"
-];
-const kernel = [
-    "__callee__",
-    "__dir__",
-    "__id__",
-    "__method__",
-    "__send__",
-    "!",
-    "!=",
-    "!~",
-    "<",
-    "<=",
-    "<=>",
-    "==",
-    "===",
-    "=~",
-    ">",
-    ">=",
-    "abort",
-    "ancestors",
-    "at_exit",
-    "autoload",
-    "autoload?",
-    "binding",
-    "block_given?",
-    "caller",
-    "caller_locations",
-    "catch",
-    "class",
-    "class_eval",
-    "class_exec",
-    "class_variable_defined?",
-    "class_variable_get",
-    "class_variable_set",
-    "class_variables",
-    "clone",
-    "const_defined?",
-    "const_get",
-    "const_missing",
-    "const_set",
-    "constants",
-    "define_singleton_method",
-    "deprecate_constant",
-    "display",
-    "dup",
-    "enum_for",
-    "eql?",
-    "equal?",
-    "eval",
-    "exec",
-    "exit",
-    "exit!",
-    "extend",
-    "fail",
-    "fork",
-    "format",
-    "freeze",
-    "frozen?",
-    "gets",
-    "global_variables",
-    "hash",
-    "include",
-    "include?",
-    "included_modules",
-    "inspect",
-    "instance_eval",
-    "instance_exec",
-    "instance_method",
-    "instance_methods",
-    "instance_of?",
-    "instance_variable_defined?",
-    "instance_variable_get",
-    "instance_variable_set",
-    "instance_variables",
-    "is_a?",
-    "iterator?",
-    "itself",
-    "kind_of?",
-    "lambda",
-    "load",
-    "local_variables",
-    "loop",
-    "method",
-    "method_defined?",
-    "methods",
-    "module_eval",
-    "module_exec",
-    "name",
-    "new",
-    "nil?",
-    "object_id",
-    "open",
-    "p",
-    "prepend",
-    "print",
-    "printf",
-    "private_class_method",
-    "private_constant",
-    "private_instance_methods",
-    "private_method_defined?",
-    "private_methods",
-    "proc",
-    "protected_instance_methods",
-    "protected_method_defined?",
-    "protected_methods",
-    "public_class_method",
-    "public_constant",
-    "public_instance_method",
-    "public_instance_methods",
-    "public_method",
-    "public_method_defined?",
-    "public_methods",
-    "public_send",
-    "putc",
-    "puts",
-    "raise",
-    "rand",
-    "readline",
-    "readlines",
-    "remove_class_variable",
-    "remove_instance_variable",
-    "require",
-    "require_relative",
-    "respond_to?",
-    "select",
-    "send",
-    "set_trace_func",
-    "singleton_class",
-    "singleton_class?",
-    "singleton_method",
-    "singleton_methods",
-    "sleep",
-    "spawn",
-    "sprintf",
-    "srand",
-    "syscall",
-    "system",
-    "taint",
-    "tainted?",
-    "tap",
-    "test",
-    "throw",
-    "to_enum",
-    "to_s",
-    "trace_var",
-    "trap",
-    "trust",
-    "untaint",
-    "untrace_var",
-    "untrust",
-    "untrusted?",
-    "warn"
-];
-exports.globals = kernel.concat(globalClasses);
-exports.reservedProperties = [
-    "__id__",
-    "__send__",
-    "break",
-    "call",
-    "case",
-    "class",
-    "clone",
-    "constrained_type",
-    "constrained?",
-    "constrained",
-    "constructor",
-    "default",
-    "define_singleton_method",
-    "display",
-    "dup",
-    "enum_for",
-    "enum",
-    "extend",
-    "freeze",
-    "gem",
-    "hash",
-    "inspect",
-    "instance_eval",
-    "instance_exec",
-    "instance_variable_defined?",
-    "instance_variable_get",
-    "instance_variable_set",
-    "instance_variables",
-    "itself",
-    "meta",
-    "method",
-    "methods",
-    "next",
-    "object_id",
-    "optional",
-    "options",
-    "pristine",
-    "private_methods",
-    "protected_methods",
-    "public_method",
-    "public_methods",
-    "public_send",
-    "remove_instance_variable",
-    "rule",
-    "safe",
-    "self",
-    "send",
-    "singleton_class",
-    "singleton_method",
-    "singleton_methods",
-    "taint",
-    "tap",
-    "to_ast",
-    "to_enum",
-    "to_json",
-    "to_s",
-    "trust",
-    "try",
-    "type",
-    "untaint",
-    "undef",
-    "untrust",
-    "while",
-    "with"
-];

package/dist/quicktype-core/rewrites/CombineClasses.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { RunContext } from "../Run";
-export declare function combineClasses(ctx: RunContext, graph: TypeGraph, alphabetizeProperties: boolean, conflateNumbers: boolean, onlyWithSameProperties: boolean, debugPrintReconstitution: boolean): TypeGraph;

package/dist/quicktype-core/rewrites/CombineClasses.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineClasses = void 0;
-const Type_1 = require("../Type");
-const TypeUtils_1 = require("../TypeUtils");
-const Support_1 = require("../support/Support");
-const UnifyClasses_1 = require("../UnifyClasses");
-const REQUIRED_OVERLAP = 3 / 4;
-// FIXME: Allow some type combinations to unify, like different enums,
-// enums with strings, integers with doubles, maps with objects of
-// the correct type.
-function typeSetsCanBeCombined(s1, s2) {
-    return (0, Type_1.setOperationCasesEqual)(s1, s2, true, (a, b) => a.structurallyCompatible(b, true));
-}
-function canBeCombined(c1, c2, onlyWithSameProperties) {
-    const p1 = c1.getProperties();
-    const p2 = c2.getProperties();
-    if (onlyWithSameProperties) {
-        if (p1.size !== p2.size) {
-            return false;
-        }
-    }
-    else {
-        if (p1.size < p2.size * REQUIRED_OVERLAP || p2.size < p1.size * REQUIRED_OVERLAP) {
-            return false;
-        }
-    }
-    let larger;
-    let smaller;
-    if (p1.size > p2.size) {
-        larger = p1;
-        smaller = p2;
-    }
-    else {
-        larger = p2;
-        smaller = p1;
-    }
-    let maxFaults;
-    if (onlyWithSameProperties) {
-        maxFaults = 0;
-    }
-    else {
-        const minOverlap = Math.ceil(larger.size * REQUIRED_OVERLAP);
-        maxFaults = smaller.size - minOverlap;
-    }
-    (0, Support_1.assert)(maxFaults >= 0, "Max faults negative");
-    const commonProperties = [];
-    let faults = 0;
-    for (const [name] of smaller) {
-        if (larger.has(name)) {
-            commonProperties.push(name);
-        }
-        else {
-            faults += 1;
-            if (faults > maxFaults)
-                break;
-        }
-    }
-    if (faults > maxFaults)
-        return false;
-    for (const name of commonProperties) {
-        let ts = smaller.get(name);
-        let tl = larger.get(name);
-        if (ts === undefined || tl === undefined) {
-            return (0, Support_1.panic)(`Both classes should have property ${name}`);
-        }
-        const tsCases = (0, TypeUtils_1.nonNullTypeCases)(ts.type);
-        const tlCases = (0, TypeUtils_1.nonNullTypeCases)(tl.type);
-        if (tsCases.size > 0 && tlCases.size > 0 && !typeSetsCanBeCombined(tsCases, tlCases)) {
-            return false;
-        }
-    }
-    return true;
-}
-function tryAddToClique(c, clique, onlyWithSameProperties) {
-    for (const prototype of clique.prototypes) {
-        if (prototype.structurallyCompatible(c)) {
-            clique.members.push(c);
-            return true;
-        }
-    }
-    for (const prototype of clique.prototypes) {
-        if (canBeCombined(prototype, c, onlyWithSameProperties)) {
-            clique.prototypes.push(c);
-            clique.members.push(c);
-            return true;
-        }
-    }
-    return false;
-}
-function findSimilarityCliques(graph, onlyWithSameProperties, includeFixedClasses) {
-    const classCandidates = Array.from(graph.allNamedTypesSeparated().objects).filter(o => o instanceof Type_1.ClassType && (includeFixedClasses || !o.isFixed));
-    const cliques = [];
-    for (const c of classCandidates) {
-        let cliqueIndex = undefined;
-        for (let i = 0; i < cliques.length; i++) {
-            if (tryAddToClique(c, cliques[i], onlyWithSameProperties)) {
-                cliqueIndex = i;
-                break;
-            }
-        }
-        if (cliqueIndex === undefined) {
-            // New clique
-            cliqueIndex = cliques.length;
-            cliques.push({ members: [c], prototypes: [c] });
-        }
-        // Move the clique we just added to to the front, in the hope that
-        // some cliques are more often added to than others, and they'll
-        // move to the front.
-        const tmp = cliques[0];
-        cliques[0] = cliques[cliqueIndex];
-        cliques[cliqueIndex] = tmp;
-    }
-    return cliques.map(clique => clique.members).filter(cl => cl.length > 1);
-}
-function combineClasses(ctx, graph, alphabetizeProperties, conflateNumbers, onlyWithSameProperties, debugPrintReconstitution) {
-    const cliques = ctx.time("  find similarity cliques", () => findSimilarityCliques(graph, onlyWithSameProperties, false));
-    function makeCliqueClass(clique, builder, forwardingRef) {
-        (0, Support_1.assert)(clique.size > 0, "Clique can't be empty");
-        const attributes = (0, TypeUtils_1.combineTypeAttributesOfTypes)("union", clique);
-        return (0, UnifyClasses_1.unifyTypes)(clique, attributes, builder, (0, UnifyClasses_1.unionBuilderForUnification)(builder, false, false, conflateNumbers), conflateNumbers, forwardingRef);
-    }
-    return graph.rewrite("combine classes", ctx.stringTypeMapping, alphabetizeProperties, cliques, debugPrintReconstitution, makeCliqueClass);
-}
-exports.combineClasses = combineClasses;

package/dist/quicktype-core/rewrites/ExpandStrings.d.ts

@@ -1,4 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { RunContext } from "../Run";
-export type EnumInference = "none" | "all" | "infer";
-export declare function expandStrings(ctx: RunContext, graph: TypeGraph, inference: EnumInference): TypeGraph;

package/dist/quicktype-core/rewrites/ExpandStrings.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandStrings = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeUtils_1 = require("../TypeUtils");
-const Support_1 = require("../support/Support");
-const TypeAttributes_1 = require("../attributes/TypeAttributes");
-const StringTypes_1 = require("../attributes/StringTypes");
-const MIN_LENGTH_FOR_ENUM = 10;
-const MIN_LENGTH_FOR_OVERLAP = 5;
-const REQUIRED_OVERLAP = 3 / 4;
-function isOwnEnum({ numValues, cases }) {
-    return numValues >= MIN_LENGTH_FOR_ENUM && cases.size < Math.sqrt(numValues);
-}
-function enumCasesOverlap(newCases, existingCases, newAreSubordinate) {
-    const smaller = newAreSubordinate ? newCases.size : Math.min(newCases.size, existingCases.size);
-    const overlap = (0, collection_utils_1.setIntersect)(newCases, existingCases).size;
-    return overlap >= smaller * REQUIRED_OVERLAP;
-}
-function isAlwaysEmptyString(cases) {
-    return cases.length === 1 && cases[0] === "";
-}
-function expandStrings(ctx, graph, inference) {
-    const stringTypeMapping = ctx.stringTypeMapping;
-    const allStrings = Array.from(graph.allTypesUnordered()).filter(t => t.kind === "string" && (0, TypeUtils_1.stringTypesForType)(t).isRestricted);
-    function makeEnumInfo(t) {
-        const stringTypes = (0, TypeUtils_1.stringTypesForType)(t);
-        const mappedStringTypes = stringTypes.applyStringTypeMapping(stringTypeMapping);
-        if (!mappedStringTypes.isRestricted)
-            return undefined;
-        const cases = (0, Support_1.defined)(mappedStringTypes.cases);
-        if (cases.size === 0)
-            return undefined;
-        const numValues = (0, collection_utils_1.iterableReduce)(cases.values(), 0, (a, b) => a + b);
-        if (inference !== "all") {
-            const keys = Array.from(cases.keys());
-            if (isAlwaysEmptyString(keys))
-                return undefined;
-            const someCaseIsNotNumber = (0, collection_utils_1.iterableSome)(keys, key => /^(\-|\+)?[0-9]+(\.[0-9]+)?$/.test(key) === false);
-            if (!someCaseIsNotNumber)
-                return undefined;
-        }
-        return { cases: new Set(cases.keys()), numValues };
-    }
-    const enumInfos = new Map();
-    const enumSets = [];
-    if (inference !== "none") {
-        for (const t of allStrings) {
-            const enumInfo = makeEnumInfo(t);
-            if (enumInfo === undefined)
-                continue;
-            enumInfos.set(t, enumInfo);
-        }
-        function findOverlap(newCases, newAreSubordinate) {
-            return enumSets.findIndex(s => enumCasesOverlap(newCases, s, newAreSubordinate));
-        }
-        // First, make case sets for all the enums that stand on their own.  If
-        // we find some overlap (searching eagerly), make unions.
-        for (const t of Array.from(enumInfos.keys())) {
-            const enumInfo = (0, Support_1.defined)(enumInfos.get(t));
-            const cases = enumInfo.cases;
-            if (inference === "all") {
-                enumSets.push(cases);
-            }
-            else {
-                if (!isOwnEnum(enumInfo))
-                    continue;
-                const index = findOverlap(cases, false);
-                if (index >= 0) {
-                    // console.log(
-                    //     `unifying ${JSON.stringify(Array.from(cases))} with ${JSON.stringify(
-                    //         Array.from(enumSets[index])
-                    //     )}`
-                    // );
-                    enumSets[index] = (0, collection_utils_1.setUnion)(enumSets[index], cases);
-                }
-                else {
-                    // console.log(`adding new ${JSON.stringify(Array.from(cases))}`);
-                    enumSets.push(cases);
-                }
-            }
-            // Remove the ones we're done with.
-            enumInfos.delete(t);
-        }
-        if (inference === "all") {
-            (0, Support_1.assert)(enumInfos.size === 0);
-        }
-        // Now see if we can unify the rest with some a set we found in the
-        // previous step.
-        for (const [, enumInfo] of enumInfos.entries()) {
-            if (enumInfo.numValues < MIN_LENGTH_FOR_OVERLAP)
-                continue;
-            const index = findOverlap(enumInfo.cases, true);
-            if (index >= 0) {
-                // console.log(
-                //     `late unifying ${JSON.stringify(Array.from(enumInfo.cases))} with ${JSON.stringify(
-                //         Array.from(enumSets[index])
-                //     )}`
-                // );
-                enumSets[index] = (0, collection_utils_1.setUnion)(enumSets[index], enumInfo.cases);
-            }
-        }
-    }
-    function replaceString(group, builder, forwardingRef) {
-        (0, Support_1.assert)(group.size === 1);
-        const t = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(group));
-        const stringTypes = (0, TypeUtils_1.stringTypesForType)(t);
-        const attributes = (0, collection_utils_1.mapFilter)(t.getAttributes(), a => a !== stringTypes);
-        const mappedStringTypes = stringTypes.applyStringTypeMapping(stringTypeMapping);
-        if (!mappedStringTypes.isRestricted) {
-            return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
-        }
-        const setMatches = inference === "all" ? collection_utils_1.areEqual : collection_utils_1.setIsSuperset;
-        const types = [];
-        const cases = (0, Support_1.defined)(mappedStringTypes.cases);
-        if (cases.size > 0) {
-            const keys = new Set(cases.keys());
-            const fullCases = enumSets.find(s => setMatches(s, keys));
-            if (inference !== "none" && !isAlwaysEmptyString(Array.from(keys)) && fullCases !== undefined) {
-                types.push(builder.getEnumType(TypeAttributes_1.emptyTypeAttributes, fullCases));
-            }
-            else {
-                return builder.getStringType(attributes, StringTypes_1.StringTypes.unrestricted, forwardingRef);
-            }
-        }
-        const transformations = mappedStringTypes.transformations;
-        // FIXME: This is probably wrong, or at least overly conservative.  This is for the case
-        // where some attributes are identity ones, i.e. where we can't merge the primitive types,
-        // like it happens in the line after the `if`.  The case where this occured was with URI
-        // attributes: we had two separate string types with different URI attributes, but because
-        // both are rewritten via `getPrimitiveType` below without any attributes, they end up
-        // being the same string type.
-        if (types.length === 0 && transformations.size === 1) {
-            const kind = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(transformations));
-            return builder.getPrimitiveType(kind, attributes, forwardingRef);
-        }
-        types.push(...Array.from(transformations).map(k => builder.getPrimitiveType(k)));
-        (0, Support_1.assert)(types.length > 0, "We got an empty string type");
-        return builder.getUnionType(attributes, new Set(types), forwardingRef);
-    }
-    return graph.rewrite("expand strings", stringTypeMapping, false, allStrings.map(t => [t]), ctx.debugPrintReconstitution, replaceString);
-}
-exports.expandStrings = expandStrings;

package/dist/quicktype-core/rewrites/FlattenStrings.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { StringTypeMapping } from "../TypeBuilder";
-export declare function flattenStrings(graph: TypeGraph, stringTypeMapping: StringTypeMapping, debugPrintReconstitution: boolean): TypeGraph;

package/dist/quicktype-core/rewrites/FlattenStrings.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenStrings = void 0;
-const collection_utils_1 = require("collection-utils");
-const TypeUtils_1 = require("../TypeUtils");
-const Support_1 = require("../support/Support");
-const TypeAttributes_1 = require("../attributes/TypeAttributes");
-// A union needs replacing if it contains more than one string type, one of them being
-// a basic string type.
-function unionNeedsReplacing(u) {
-    const stringMembers = u.stringTypeMembers;
-    if (stringMembers.size <= 1)
-        return undefined;
-    const stringType = u.findMember("string");
-    if (stringType === undefined)
-        return undefined;
-    (0, Support_1.assert)(!(0, TypeUtils_1.stringTypesForType)(stringType).isRestricted, "We must only flatten strings if we have no restriced strings");
-    return stringMembers;
-}
-// Replaces all string types in an enum with the basic string type.
-function replaceUnion(group, builder, forwardingRef) {
-    (0, Support_1.assert)(group.size === 1);
-    const u = (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(group));
-    const stringMembers = (0, Support_1.defined)(unionNeedsReplacing(u));
-    const stringAttributes = (0, TypeUtils_1.combineTypeAttributesOfTypes)("union", stringMembers);
-    const types = [];
-    for (const t of u.members) {
-        if (stringMembers.has(t))
-            continue;
-        types.push(builder.reconstituteType(t));
-    }
-    if (types.length === 0) {
-        return builder.getStringType((0, TypeAttributes_1.combineTypeAttributes)("union", stringAttributes, u.getAttributes()), undefined, forwardingRef);
-    }
-    types.push(builder.getStringType(stringAttributes, undefined));
-    return builder.getUnionType(u.getAttributes(), new Set(types), forwardingRef);
-}
-function flattenStrings(graph, stringTypeMapping, debugPrintReconstitution) {
-    const allUnions = graph.allNamedTypesSeparated().unions;
-    const unionsToReplace = Array.from(allUnions)
-        .filter(unionNeedsReplacing)
-        .map(t => [t]);
-    return graph.rewrite("flatten strings", stringTypeMapping, false, unionsToReplace, debugPrintReconstitution, replaceUnion);
-}
-exports.flattenStrings = flattenStrings;

package/dist/quicktype-core/rewrites/FlattenUnions.d.ts

@@ -1,3 +0,0 @@
-import { TypeGraph } from "../TypeGraph";
-import { StringTypeMapping } from "../TypeBuilder";
-export declare function flattenUnions(graph: TypeGraph, stringTypeMapping: StringTypeMapping, conflateNumbers: boolean, makeObjectTypes: boolean, debugPrintReconstitution: boolean): [TypeGraph, boolean];