quicktype 18.0.5 → 19.0.4

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

@@ -1,71 +0,0 @@
-/**
- * Primary options show up in the web UI in the "Language" settings tab,
- * secondary options in "Other".
- */
-export type OptionKind = "primary" | "secondary";
-export interface OptionDefinition {
-    name: string;
-    type: StringConstructor | BooleanConstructor;
-    kind?: OptionKind;
-    renderer?: boolean;
-    alias?: string;
-    multiple?: boolean;
-    defaultOption?: boolean;
-    defaultValue?: any;
-    typeLabel?: string;
-    description: string;
-    legalValues?: string[];
-}
-/**
- * The superclass for target language options.  You probably want to use one of its
- * subclasses, `BooleanOption`, `EnumOption`, or `StringOption`.
- */
-export declare abstract class Option<T> {
-    readonly definition: OptionDefinition;
-    constructor(definition: OptionDefinition);
-    getValue(values: {
-        [name: string]: any;
-    }): T;
-    get cliDefinitions(): {
-        display: OptionDefinition[];
-        actual: OptionDefinition[];
-    };
-}
-export type OptionValueType<O> = O extends Option<infer T> ? T : never;
-export type OptionValues<T> = {
-    [P in keyof T]: OptionValueType<T[P]>;
-};
-export declare function getOptionValues<T extends {
-    [name: string]: Option<any>;
-}>(options: T, untypedOptionValues: {
-    [name: string]: any;
-}): OptionValues<T>;
-/**
- * A target language option that allows setting a boolean flag.
- */
-export declare class BooleanOption extends Option<boolean> {
-    /**
-     * @param name The shorthand name.
-     * @param description Short-ish description of the option.
-     * @param defaultValue The default value.
-     * @param kind Whether it's a primary or secondary option.
-     */
-    constructor(name: string, description: string, defaultValue: boolean, kind?: OptionKind);
-    get cliDefinitions(): {
-        display: OptionDefinition[];
-        actual: OptionDefinition[];
-    };
-    getValue(values: {
-        [name: string]: any;
-    }): boolean;
-}
-export declare class StringOption extends Option<string> {
-    constructor(name: string, description: string, typeLabel: string, defaultValue: string, kind?: OptionKind);
-}
-export declare class EnumOption<T> extends Option<T> {
-    private readonly _values;
-    constructor(name: string, description: string, values: [string, T][], defaultValue?: string | undefined, kind?: OptionKind);
-    getValue(values: {
-        [name: string]: any;
-    }): T;
-}

package/dist/quicktype-core/RendererOptions.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumOption = exports.StringOption = exports.BooleanOption = exports.getOptionValues = exports.Option = void 0;
-const Support_1 = require("./support/Support");
-const Messages_1 = require("./Messages");
-const collection_utils_1 = require("collection-utils");
-/**
- * The superclass for target language options.  You probably want to use one of its
- * subclasses, `BooleanOption`, `EnumOption`, or `StringOption`.
- */
-class Option {
-    definition;
-    constructor(definition) {
-        definition.renderer = true;
-        this.definition = definition;
-        (0, Support_1.assert)(definition.kind !== undefined, "Renderer option kind must be defined");
-    }
-    getValue(values) {
-        const value = values[this.definition.name];
-        if (value === undefined) {
-            return this.definition.defaultValue;
-        }
-        return value;
-    }
-    get cliDefinitions() {
-        return { actual: [this.definition], display: [this.definition] };
-    }
-}
-exports.Option = Option;
-function getOptionValues(options, untypedOptionValues) {
-    const optionValues = {};
-    for (const name of Object.getOwnPropertyNames(options)) {
-        optionValues[name] = options[name].getValue(untypedOptionValues);
-    }
-    return optionValues;
-}
-exports.getOptionValues = getOptionValues;
-/**
- * A target language option that allows setting a boolean flag.
- */
-class BooleanOption extends Option {
-    /**
-     * @param name The shorthand name.
-     * @param description Short-ish description of the option.
-     * @param defaultValue The default value.
-     * @param kind Whether it's a primary or secondary option.
-     */
-    constructor(name, description, defaultValue, kind = "primary") {
-        super({
-            name,
-            kind,
-            type: Boolean,
-            description,
-            defaultValue
-        });
-    }
-    get cliDefinitions() {
-        const negated = Object.assign({}, this.definition, {
-            name: `no-${this.definition.name}`,
-            defaultValue: !this.definition.defaultValue
-        });
-        const display = Object.assign({}, this.definition, {
-            name: `[no-]${this.definition.name}`,
-            description: `${this.definition.description} (${this.definition.defaultValue ? "on" : "off"} by default)`
-        });
-        return {
-            display: [display],
-            actual: [this.definition, negated]
-        };
-    }
-    getValue(values) {
-        let value = values[this.definition.name];
-        if (value === undefined) {
-            value = this.definition.defaultValue;
-        }
-        let negated = values[`no-${this.definition.name}`];
-        if (negated === undefined) {
-            negated = !this.definition.defaultValue;
-        }
-        if (value === "true") {
-            value = true;
-        }
-        else if (value === "false") {
-            value = false;
-        }
-        if (this.definition.defaultValue) {
-            return value && !negated;
-        }
-        else {
-            return value || !negated;
-        }
-    }
-}
-exports.BooleanOption = BooleanOption;
-class StringOption extends Option {
-    constructor(name, description, typeLabel, defaultValue, kind = "primary") {
-        const definition = {
-            name,
-            kind,
-            type: String,
-            description,
-            typeLabel,
-            defaultValue
-        };
-        super(definition);
-    }
-}
-exports.StringOption = StringOption;
-class EnumOption extends Option {
-    _values;
-    constructor(name, description, values, defaultValue = undefined, kind = "primary") {
-        if (defaultValue === undefined) {
-            defaultValue = values[0][0];
-        }
-        const definition = {
-            name,
-            kind,
-            type: String,
-            description,
-            typeLabel: values.map(([n, _]) => n).join("|"),
-            legalValues: values.map(([n, _]) => n),
-            defaultValue
-        };
-        super(definition);
-        this._values = {};
-        for (const [n, v] of values) {
-            this._values[n] = v;
-        }
-    }
-    getValue(values) {
-        let name = values[this.definition.name];
-        if (name === undefined) {
-            name = this.definition.defaultValue;
-        }
-        if (!(0, collection_utils_1.hasOwnProperty)(this._values, name)) {
-            return (0, Messages_1.messageError)("RendererUnknownOptionValue", { value: name, name: this.definition.name });
-        }
-        return this._values[name];
-    }
-}
-exports.EnumOption = EnumOption;

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

@@ -1,174 +0,0 @@
-import { TargetLanguage, MultiFileRenderResult } from "./TargetLanguage";
-import { SerializedRenderResult } from "./Source";
-import { StringTypeMapping } from "./TypeBuilder";
-import { InputData } from "./input/Inputs";
-import { TransformedStringTypeKind } from "./Type";
-export declare function getTargetLanguage(nameOrInstance: string | TargetLanguage): TargetLanguage;
-export type RendererOptions = {
-    [name: string]: string;
-};
-export interface InferenceFlag {
-    description: string;
-    negationDescription: string;
-    explanation: string;
-    order: number;
-    stringType?: TransformedStringTypeKind;
-}
-export declare const inferenceFlagsObject: {
-    /** Whether to infer map types from JSON data */
-    inferMaps: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        order: number;
-    };
-    /** Whether to infer enum types from JSON data */
-    inferEnums: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        order: number;
-    };
-    /** Whether to convert UUID strings to UUID objects */
-    inferUuids: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
-        order: number;
-    };
-    /** Whether to assume that JSON strings that look like dates are dates */
-    inferDateTimes: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
-        order: number;
-    };
-    /** Whether to convert stringified integers to integers */
-    inferIntegerStrings: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
-        order: number;
-    };
-    /** Whether to convert stringified booleans to boolean values */
-    inferBooleanStrings: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        stringType: "date" | "time" | "date-time" | "uuid" | "uri" | "integer-string" | "bool-string";
-        order: number;
-    };
-    /** Combine similar classes.  This doesn't apply to classes from a schema, only from inference. */
-    combineClasses: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        order: number;
-    };
-    /** Whether to treat $ref as references within JSON */
-    ignoreJsonRefs: {
-        description: string;
-        negationDescription: string;
-        explanation: string;
-        order: number;
-    };
-};
-export type InferenceFlagName = keyof typeof inferenceFlagsObject;
-export declare const inferenceFlagNames: ("inferMaps" | "inferEnums" | "inferUuids" | "inferDateTimes" | "inferIntegerStrings" | "inferBooleanStrings" | "combineClasses" | "ignoreJsonRefs")[];
-export declare const inferenceFlags: {
-    [F in InferenceFlagName]: InferenceFlag;
-};
-export type InferenceFlags = {
-    [F in InferenceFlagName]: boolean;
-};
-/**
- * The options type for the main quicktype entry points,
- * `quicktypeMultiFile` and `quicktype`.
- */
-export type NonInferenceOptions = {
-    /**
-     * The target language for which to produce code.  This can be either an instance of `TargetLanguage`,
-     * or a string specifying one of the names for quicktype's built-in target languages.  For example,
-     * both `cs` and `csharp` will generate C#.
-     */
-    lang: string | TargetLanguage;
-    /** The input data from which to produce types */
-    inputData: InputData;
-    /** Put class properties in alphabetical order, instead of in the order found in the JSON */
-    alphabetizeProperties: boolean;
-    /** Make all class property optional */
-    allPropertiesOptional: boolean;
-    /**
-     * Make top-levels classes from JSON fixed.  That means even if two top-level classes are exactly
-     * the same, quicktype will still generate two separate types for them.
-     */
-    fixedTopLevels: boolean;
-    /** Don't render output.  This is mainly useful for benchmarking. */
-    noRender: boolean;
-    /** If given, output these comments at the beginning of the main output file */
-    leadingComments: string[] | undefined;
-    /** Options for the target language's renderer */
-    rendererOptions: RendererOptions;
-    /** String to use for one indentation level.  If not given, use the target language's default. */
-    indentation: string | undefined;
-    /** Name of the output file.  Note that quicktype will not write that file, but you'll get its name
-     * back as a key in the resulting `Map`.
-     */
-    outputFilename: string;
-    /** Print the type graph to the console at every processing step */
-    debugPrintGraph: boolean;
-    /** Check that we're propagating all type attributes (unless we actually can't) */
-    checkProvenance: boolean;
-    /**
-     * Print type reconstitution debug information to the console.  You'll only ever need this if
-     * you're working deep inside quicktype-core.
-     */
-    debugPrintReconstitution: boolean;
-    /**
-     * Print name gathering debug information to the console.  This might help to figure out why
-     * your types get weird names, but the output is quite arcane.
-     */
-    debugPrintGatherNames: boolean;
-    /** Print all transformations to the console prior to generating code */
-    debugPrintTransformations: boolean;
-    /** Print the time it took for each pass to run */
-    debugPrintTimes: boolean;
-    /** Print schema resolving steps */
-    debugPrintSchemaResolving: boolean;
-};
-export type Options = NonInferenceOptions & InferenceFlags;
-export interface RunContext {
-    stringTypeMapping: StringTypeMapping;
-    debugPrintReconstitution: boolean;
-    debugPrintTransformations: boolean;
-    debugPrintSchemaResolving: boolean;
-    timeSync<T>(name: string, f: () => Promise<T>): Promise<T>;
-    time<T>(name: string, f: () => T): T;
-}
-export declare const defaultInferenceFlags: InferenceFlags;
-/**
- * Run quicktype and produce one or more output files.
- *
- * @param options Partial options.  For options that are not defined, the
- * defaults will be used.
- */
-export declare function quicktypeMultiFile(options: Partial<Options>): Promise<MultiFileRenderResult>;
-export declare function quicktypeMultiFileSync(options: Partial<Options>): MultiFileRenderResult;
-/**
- * Combines a multi-file render result into a single output.  All the files
- * are concatenated and prefixed with a `//`-style comment giving the
- * filename.
- */
-export declare function combineRenderResults(result: MultiFileRenderResult): SerializedRenderResult;
-/**
- * Run quicktype like `quicktypeMultiFile`, but if there are multiple
- * output files they will all be squashed into one output, with comments at the
- * start of each file.
- *
- * @param options Partial options.  For options that are not defined, the
- * defaults will be used.
- */
-export declare function quicktype(options: Partial<Options>): Promise<SerializedRenderResult>;