quicktype 18.0.6 → 19.0.5

package/dist/quicktype-core/MarkovChain.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = exports.generate = exports.evaluate = exports.evaluateFull = exports.load = exports.train = void 0;
-const Support_1 = require("./support/Support");
-const EncodedMarkovChain_1 = require("./EncodedMarkovChain");
-function makeTrie() {
-    const arr = [];
-    for (let i = 0; i < 128; i++) {
-        arr.push(null);
-    }
-    return { count: 0, arr };
-}
-function lookup(t, seq, i) {
-    if (i >= seq.length) {
-        return t;
-    }
-    let first = seq.charCodeAt(i);
-    if (first >= 128) {
-        first = 0;
-    }
-    const n = t.arr[first];
-    if (n === null) {
-        return undefined;
-    }
-    if (typeof n === "object") {
-        return lookup(n, seq, i + 1);
-    }
-    else {
-        return n / t.count;
-    }
-}
-function increment(t, seq, i) {
-    let first = seq.charCodeAt(i);
-    if (first >= 128) {
-        first = 0;
-    }
-    if (i >= seq.length - 1) {
-        if (typeof t !== "object") {
-            return (0, Support_1.panic)("Malformed trie");
-        }
-        let n = t.arr[first];
-        if (n === null) {
-            n = 0;
-        }
-        else if (typeof n === "object") {
-            return (0, Support_1.panic)("Malformed trie");
-        }
-        t.arr[first] = n + 1;
-        t.count += 1;
-        return;
-    }
-    let st = t.arr[first];
-    if (st === null) {
-        t.arr[first] = st = makeTrie();
-    }
-    if (typeof st !== "object") {
-        return (0, Support_1.panic)("Malformed trie");
-    }
-    return increment(st, seq, i + 1);
-}
-function train(lines, depth) {
-    const trie = makeTrie();
-    for (const l of lines) {
-        for (let i = depth; i <= l.length; i++) {
-            increment(trie, l.slice(i - depth, i), 0);
-        }
-    }
-    return { trie, depth };
-}
-exports.train = train;
-function load() {
-    return JSON.parse((0, Support_1.inflateBase64)(EncodedMarkovChain_1.encodedMarkovChain));
-}
-exports.load = load;
-function evaluateFull(mc, word) {
-    const { trie, depth } = mc;
-    if (word.length < depth) {
-        return [1, []];
-    }
-    let p = 1;
-    const scores = [];
-    for (let i = depth; i <= word.length; i++) {
-        let cp = lookup(trie, word.slice(i - depth, i), 0);
-        if (typeof cp === "object") {
-            return (0, Support_1.panic)("Did we mess up the depth?");
-        }
-        if (cp === undefined) {
-            cp = 0.0001;
-        }
-        scores.push(cp);
-        p = p * cp;
-    }
-    return [Math.pow(p, 1 / (word.length - depth + 1)), scores];
-}
-exports.evaluateFull = evaluateFull;
-function evaluate(mc, word) {
-    return evaluateFull(mc, word)[0];
-}
-exports.evaluate = evaluate;
-function randomInt(lower, upper) {
-    const range = upper - lower;
-    return lower + Math.floor(Math.random() * range);
-}
-function generate(mc, state, unseenWeight) {
-    (0, Support_1.assert)(state.length === mc.depth - 1, "State and chain length don't match up");
-    const t = lookup(mc.trie, state, 0);
-    if (typeof t === "number") {
-        return (0, Support_1.panic)("Wrong depth?");
-    }
-    if (t === undefined) {
-        return String.fromCharCode(randomInt(32, 127));
-    }
-    const counts = t.arr.map((x, i) => (x === null ? (i === 0 ? 0 : unseenWeight) : x));
-    let n = 0;
-    for (const c of counts) {
-        n += c;
-    }
-    const r = randomInt(0, n);
-    let sum = 0;
-    for (let i = 0; i < counts.length; i++) {
-        sum += counts[i];
-        if (r < sum) {
-            return String.fromCharCode(i);
-        }
-    }
-    return (0, Support_1.panic)("We screwed up bookkeeping, or randomInt");
-}
-exports.generate = generate;
-function testWord(mc, word) {
-    console.log(`"${word}": ${evaluate(mc, word)}`);
-}
-function test() {
-    const mc = load();
-    testWord(mc, "url");
-    testWord(mc, "json");
-    testWord(mc, "my_property");
-    testWord(mc, "ordinary");
-    testWord(mc, "different");
-    testWord(mc, "189512");
-    testWord(mc, "2BTZIqw0ntH9MvilQ3ewNY");
-    testWord(mc, "0uBTNdNGb2OY5lou41iYL52LcDq2");
-    testWord(mc, "-KpqHmWuDOUnr1hmAhxp");
-    testWord(mc, "granularity");
-    testWord(mc, "coverage");
-    testWord(mc, "postingFrequency");
-    testWord(mc, "dataFrequency");
-    testWord(mc, "units");
-    testWord(mc, "datasetOwner");
-    testWord(mc, "organization");
-    testWord(mc, "timePeriod");
-    testWord(mc, "contactInformation");
-    testWord(mc, "\ud83d\udebe \ud83c\udd92 \ud83c\udd93 \ud83c\udd95 \ud83c\udd96 \ud83c\udd97 \ud83c\udd99 \ud83c\udfe7");
-}
-exports.test = test;

package/dist/quicktype-core/Messages.d.ts

@@ -1,294 +0,0 @@
-import { StringMap } from "./support/Support";
-import { Ref } from "./input/JSONSchemaInput";
-export type ErrorProperties = {
-    kind: "InternalError";
-    properties: {
-        message: string;
-    };
-} | {
-    kind: "MiscJSONParseError";
-    properties: {
-        description: string;
-        address: string;
-        message: string;
-    };
-} | {
-    kind: "MiscReadError";
-    properties: {
-        fileOrURL: string;
-        message: string;
-    };
-} | {
-    kind: "MiscUnicodeHighSurrogateWithoutLowSurrogate";
-    properties: {};
-} | {
-    kind: "MiscInvalidMinMaxConstraint";
-    properties: {
-        min: number;
-        max: number;
-    };
-} | {
-    kind: "InferenceJSONReferenceNotRooted";
-    properties: {
-        reference: string;
-    };
-} | {
-    kind: "InferenceJSONReferenceToUnion";
-    properties: {
-        reference: string;
-    };
-} | {
-    kind: "InferenceJSONReferenceWrongProperty";
-    properties: {
-        reference: string;
-    };
-} | {
-    kind: "InferenceJSONReferenceInvalidArrayIndex";
-    properties: {
-        reference: string;
-    };
-} | {
-    kind: "SchemaArrayIsInvalidSchema";
-    properties: {
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaNullIsInvalidSchema";
-    properties: {
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaRefMustBeString";
-    properties: {
-        actual: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaAdditionalTypesForbidRequired";
-    properties: {
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaNoTypeSpecified";
-    properties: {
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaInvalidType";
-    properties: {
-        type: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaFalseNotSupported";
-    properties: {
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaInvalidJSONSchemaType";
-    properties: {
-        type: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaRequiredMustBeStringOrStringArray";
-    properties: {
-        actual: any;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaRequiredElementMustBeString";
-    properties: {
-        element: any;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaTypeMustBeStringOrStringArray";
-    properties: {
-        actual: any;
-    };
-} | {
-    kind: "SchemaTypeElementMustBeString";
-    properties: {
-        element: any;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaArrayItemsMustBeStringOrArray";
-    properties: {
-        actual: any;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaIDMustHaveAddress";
-    properties: {
-        id: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaWrongAccessorEntryArrayLength";
-    properties: {
-        operation: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaSetOperationCasesIsNotArray";
-    properties: {
-        operation: string;
-        cases: any;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaMoreThanOneUnionMemberName";
-    properties: {
-        names: string[];
-    };
-} | {
-    kind: "SchemaCannotGetTypesFromBoolean";
-    properties: {
-        ref: string;
-    };
-} | {
-    kind: "SchemaCannotIndexArrayWithNonNumber";
-    properties: {
-        actual: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaIndexNotInArray";
-    properties: {
-        index: number;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaKeyNotInObject";
-    properties: {
-        key: string;
-        ref: Ref;
-    };
-} | {
-    kind: "SchemaFetchError";
-    properties: {
-        address: string;
-        base: Ref;
-    };
-} | {
-    kind: "SchemaFetchErrorTopLevel";
-    properties: {
-        address: string;
-    };
-} | {
-    kind: "SchemaFetchErrorAdditional";
-    properties: {
-        address: string;
-    };
-} | {
-    kind: "GraphQLNoQueriesDefined";
-    properties: {};
-} | {
-    kind: "DriverUnknownSourceLanguage";
-    properties: {
-        lang: string;
-    };
-} | {
-    kind: "DriverUnknownOutputLanguage";
-    properties: {
-        lang: string;
-    };
-} | {
-    kind: "DriverMoreThanOneInputGiven";
-    properties: {
-        topLevel: string;
-    };
-} | {
-    kind: "DriverCannotInferNameForSchema";
-    properties: {
-        uri: string;
-    };
-} | {
-    kind: "DriverNoGraphQLQueryGiven";
-    properties: {};
-} | {
-    kind: "DriverNoGraphQLSchemaInDir";
-    properties: {
-        dir: string;
-    };
-} | {
-    kind: "DriverMoreThanOneGraphQLSchemaInDir";
-    properties: {
-        dir: string;
-    };
-} | {
-    kind: "DriverSourceLangMustBeGraphQL";
-    properties: {};
-} | {
-    kind: "DriverGraphQLSchemaNeeded";
-    properties: {};
-} | {
-    kind: "DriverInputFileDoesNotExist";
-    properties: {
-        filename: string;
-    };
-} | {
-    kind: "DriverCannotMixJSONWithOtherSamples";
-    properties: {
-        dir: string;
-    };
-} | {
-    kind: "DriverCannotMixNonJSONInputs";
-    properties: {
-        dir: string;
-    };
-} | {
-    kind: "DriverUnknownDebugOption";
-    properties: {
-        option: string;
-    };
-} | {
-    kind: "DriverNoLanguageOrExtension";
-    properties: {};
-} | {
-    kind: "DriverCLIOptionParsingFailed";
-    properties: {
-        message: string;
-    };
-} | {
-    kind: "IRNoForwardDeclarableTypeInCycle";
-    properties: {};
-} | {
-    kind: "IRTypeAttributesNotPropagated";
-    properties: {
-        count: number;
-        indexes: number[];
-    };
-} | {
-    kind: "IRNoEmptyUnions";
-    properties: {};
-} | {
-    kind: "RendererUnknownOptionValue";
-    properties: {
-        value: string;
-        name: string;
-    };
-} | {
-    kind: "TypeScriptCompilerError";
-    properties: {
-        message: string;
-    };
-};
-export type ErrorKinds = ErrorProperties extends {
-    kind: infer K;
-} ? K : never;
-export type ErrorPropertiesForName<K> = Extract<ErrorProperties, {
-    kind: K;
-}> extends {
-    properties: infer P;
-} ? P : never;
-export declare class QuickTypeError extends Error {
-    readonly errorMessage: string;
-    readonly messageName: string;
-    readonly properties: StringMap;
-    constructor(errorMessage: string, messageName: string, userMessage: string, properties: StringMap);
-}
-export declare function messageError<N extends ErrorKinds>(kind: N, properties: ErrorPropertiesForName<N>): never;
-export declare function messageAssert<N extends ErrorKinds>(assertion: boolean, kind: N, properties: ErrorPropertiesForName<N>): void;

package/dist/quicktype-core/Messages.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.messageAssert = exports.messageError = exports.QuickTypeError = void 0;
-const errorMessages = {
-    InternalError: "Internal error: ${message}",
-    // Misc
-    MiscJSONParseError: "Syntax error in ${description} JSON ${address}: ${message}",
-    MiscReadError: "Cannot read from file or URL ${fileOrURL}: ${message}",
-    MiscUnicodeHighSurrogateWithoutLowSurrogate: "Malformed unicode: High surrogate not followed by low surrogate",
-    MiscInvalidMinMaxConstraint: "Invalid min-max constraint: ${min}-${max}",
-    // Inference
-    InferenceJSONReferenceNotRooted: "JSON reference doesn't start with '#/': ${reference}",
-    InferenceJSONReferenceToUnion: "JSON reference points to a union type: ${reference}",
-    InferenceJSONReferenceWrongProperty: "JSON reference points to a non-existant property: ${reference}",
-    InferenceJSONReferenceInvalidArrayIndex: "JSON reference uses invalid array index: ${reference}",
-    // JSON Schema input
-    SchemaArrayIsInvalidSchema: "An array is not a valid JSON Schema at ${ref}",
-    SchemaNullIsInvalidSchema: "null is not a valid JSON Schema at ${ref}",
-    SchemaRefMustBeString: "$ref must be a string, but is an ${actual} at ${ref}",
-    SchemaAdditionalTypesForbidRequired: "Can't have non-specified required properties but forbidden additionalTypes at ${ref}",
-    SchemaNoTypeSpecified: "JSON Schema must specify at least one type at ${ref}",
-    SchemaInvalidType: "Invalid type ${type} in JSON Schema at ${ref}",
-    SchemaFalseNotSupported: 'Schema "false" is not supported at ${ref}',
-    SchemaInvalidJSONSchemaType: "Value of type ${type} is not valid JSON Schema at ${ref}",
-    SchemaRequiredMustBeStringOrStringArray: "`required` must be string or array of strings, but is ${actual} at ${ref}",
-    SchemaRequiredElementMustBeString: "`required` must contain only strings, but it has ${element}, at ${ref}",
-    SchemaTypeMustBeStringOrStringArray: "`type` must be string or array of strings, but is ${actual}",
-    SchemaTypeElementMustBeString: "`type` must contain only strings, but it has ${element}",
-    SchemaArrayItemsMustBeStringOrArray: "Array items must be an array or an object, but is ${actual}",
-    SchemaIDMustHaveAddress: "$id ${id} doesn't have an address at ${ref}",
-    SchemaWrongAccessorEntryArrayLength: "Accessor entry array must have the same number of entries as the ${operation} at ${ref}",
-    SchemaSetOperationCasesIsNotArray: "${operation} cases must be an array, but is ${cases}, at ${ref}",
-    SchemaMoreThanOneUnionMemberName: "More than one name given for union member: ${names}",
-    SchemaCannotGetTypesFromBoolean: "Schema value to get top-level types from must be an object, but is boolean, at ${ref}",
-    SchemaCannotIndexArrayWithNonNumber: "Trying to index array in schema with key that is not a number, but is ${actual} at ${ref}",
-    SchemaIndexNotInArray: "Index ${index} out of range of schema array at ${ref}",
-    SchemaKeyNotInObject: "Key ${key} not in schema object at ${ref}",
-    SchemaFetchError: "Could not fetch schema ${address}, referred to from ${base}",
-    SchemaFetchErrorTopLevel: "Could not fetch top-level schema ${address}",
-    SchemaFetchErrorAdditional: "Could not fetch additional schema ${address}",
-    // GraphQL input
-    GraphQLNoQueriesDefined: "GraphQL file doesn't have any queries defined.",
-    // Driver
-    DriverUnknownSourceLanguage: "Unknown source language ${lang}",
-    DriverUnknownOutputLanguage: "Unknown output language ${lang}",
-    DriverMoreThanOneInputGiven: "More than one input given for top-level ${topLevel}",
-    DriverCannotInferNameForSchema: "Cannot infer name for schema ${uri}",
-    DriverNoGraphQLQueryGiven: "Please specify at least one GraphQL query as input",
-    DriverNoGraphQLSchemaInDir: "No GraphQL schema in ${dir}",
-    DriverMoreThanOneGraphQLSchemaInDir: "More than one GraphQL schema in ${dir}",
-    DriverSourceLangMustBeGraphQL: "If a GraphQL schema is specified, the source language must be GraphQL",
-    DriverGraphQLSchemaNeeded: "Please specify a GraphQL schema with --graphql-schema or --graphql-introspect",
-    DriverInputFileDoesNotExist: "Input file ${filename} does not exist",
-    DriverCannotMixJSONWithOtherSamples: "Cannot mix JSON samples with JSON Schems, GraphQL, or TypeScript in input subdirectory ${dir}",
-    DriverCannotMixNonJSONInputs: "Cannot mix JSON Schema, GraphQL, and TypeScript in an input subdirectory ${dir}",
-    DriverUnknownDebugOption: "Unknown debug option ${option}",
-    DriverNoLanguageOrExtension: "Please specify a language (--lang) or an output file extension",
-    DriverCLIOptionParsingFailed: "Option parsing failed: ${message}",
-    // IR
-    IRNoForwardDeclarableTypeInCycle: "Cannot resolve cycle because it doesn't contain types that can be forward declared",
-    IRTypeAttributesNotPropagated: "Type attributes for ${count} types were not carried over to the new graph: ${indexes}",
-    IRNoEmptyUnions: "Trying to make an empty union - do you have an impossible type in your schema?",
-    // Rendering
-    RendererUnknownOptionValue: "Unknown value ${value} for option ${name}",
-    // TypeScript input
-    TypeScriptCompilerError: "TypeScript error: ${message}"
-};
-class QuickTypeError extends Error {
-    errorMessage;
-    messageName;
-    properties;
-    constructor(errorMessage, messageName, userMessage, properties) {
-        super(userMessage);
-        this.errorMessage = errorMessage;
-        this.messageName = messageName;
-        this.properties = properties;
-    }
-}
-exports.QuickTypeError = QuickTypeError;
-function messageError(kind, properties) {
-    const message = errorMessages[kind];
-    let userMessage = message;
-    const propertiesMap = properties;
-    for (const name of Object.getOwnPropertyNames(propertiesMap)) {
-        let value = propertiesMap[name];
-        if (typeof value === "object" && typeof value.toString === "function") {
-            value = value.toString();
-        }
-        else if (typeof value.message === "string") {
-            value = value.message;
-        }
-        else if (typeof value !== "string") {
-            value = JSON.stringify(value);
-        }
-        userMessage = userMessage.replace("${" + name + "}", value);
-    }
-    throw new QuickTypeError(message, kind, userMessage, propertiesMap);
-}
-exports.messageError = messageError;
-function messageAssert(assertion, kind, properties) {
-    if (assertion)
-        return;
-    return messageError(kind, properties);
-}
-exports.messageAssert = messageAssert;

package/dist/quicktype-core/Naming.d.ts

@@ -1,64 +0,0 @@
-export declare class Namespace {
-    readonly forbiddenNamespaces: ReadonlySet<Namespace>;
-    readonly additionalForbidden: ReadonlySet<Name>;
-    private readonly _children;
-    private readonly _members;
-    constructor(_name: string, parent: Namespace | undefined, forbiddenNamespaces: Iterable<Namespace>, additionalForbidden: Iterable<Name>);
-    private addChild;
-    get children(): ReadonlySet<Namespace>;
-    get members(): ReadonlySet<Name>;
-    get forbiddenNameds(): ReadonlySet<Name>;
-    add<TName extends Name>(named: TName): TName;
-}
-export type NameStyle = (rawName: string) => string;
-export declare class Namer {
-    readonly name: string;
-    readonly nameStyle: NameStyle;
-    private readonly _prefixes;
-    constructor(name: string, nameStyle: NameStyle, prefixes: string[]);
-    assignNames(names: ReadonlyMap<Name, string>, forbiddenNamesIterable: Iterable<string>, namesToAssignIterable: Iterable<Name>): ReadonlyMap<Name, string>;
-}
-export declare function funPrefixNamer(name: string, nameStyle: NameStyle): Namer;
-export declare abstract class Name {
-    private readonly _namingFunction;
-    readonly order: number;
-    private readonly _associates;
-    constructor(_namingFunction: Namer | undefined, order: number);
-    addAssociate(associate: AssociatedName): void;
-    abstract get dependencies(): ReadonlyArray<Name>;
-    isFixed(): this is FixedName;
-    get namingFunction(): Namer;
-    abstract proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
-    firstProposedName(names: ReadonlyMap<Name, string>): string;
-    nameAssignments(forbiddenNames: ReadonlySet<string>, assignedName: string): ReadonlyMap<Name, string> | null;
-}
-export declare class FixedName extends Name {
-    private readonly _fixedName;
-    constructor(_fixedName: string);
-    get dependencies(): ReadonlyArray<Name>;
-    addAssociate(_: AssociatedName): never;
-    get fixedName(): string;
-    proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
-}
-export declare class SimpleName extends Name {
-    private readonly _unstyledNames;
-    constructor(unstyledNames: Iterable<string>, namingFunction: Namer, order: number);
-    get dependencies(): ReadonlyArray<Name>;
-    proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
-}
-export declare class AssociatedName extends Name {
-    private readonly _sponsor;
-    readonly getName: (sponsorName: string) => string;
-    constructor(_sponsor: Name, order: number, getName: (sponsorName: string) => string);
-    get dependencies(): ReadonlyArray<Name>;
-    proposeUnstyledNames(_?: ReadonlyMap<Name, string>): never;
-}
-export declare class DependencyName extends Name {
-    private readonly _proposeUnstyledName;
-    private readonly _dependencies;
-    constructor(namingFunction: Namer | undefined, order: number, _proposeUnstyledName: (lookup: (n: Name) => string) => string);
-    get dependencies(): ReadonlyArray<Name>;
-    proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
-}
-export declare function keywordNamespace(name: string, keywords: string[]): Namespace;
-export declare function assignNames(rootNamespaces: Iterable<Namespace>): ReadonlyMap<Name, string>;