quicktype 18.0.5 → 19.0.4

package/dist/quicktype-core/language/Pike.d.ts

@@ -1,37 +0,0 @@
-import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
-import { Name, Namer } from "../Naming";
-import { Option } from "../RendererOptions";
-import { RenderContext } from "../Renderer";
-import { MultiWord } from "../Source";
-import { TargetLanguage } from "../TargetLanguage";
-import { Type, ClassType, EnumType, UnionType } from "../Type";
-export declare const pikeOptions: {};
-export declare class PikeTargetLanguage extends TargetLanguage {
-    constructor();
-    protected getOptions(): Option<any>[];
-    protected makeRenderer(renderContext: RenderContext): PikeRenderer;
-}
-export declare class PikeRenderer extends ConvenienceRenderer {
-    protected emitSourceStructure(): void;
-    protected get enumCasesInGlobalNamespace(): boolean;
-    protected makeEnumCaseNamer(): Namer;
-    protected makeNamedTypeNamer(): Namer;
-    protected makeUnionMemberNamer(): Namer;
-    protected namerForObjectProperty(): Namer;
-    protected forbiddenNamesForGlobalNamespace(): string[];
-    protected forbiddenForObjectProperties(_c: ClassType, _className: Name): ForbiddenWordsInfo;
-    protected forbiddenForEnumCases(_e: EnumType, _enumName: Name): ForbiddenWordsInfo;
-    protected forbiddenForUnionMembers(_u: UnionType, _unionName: Name): ForbiddenWordsInfo;
-    protected sourceFor(t: Type): MultiWord;
-    protected emitClassDefinition(c: ClassType, className: Name): void;
-    protected emitEnum(e: EnumType, enumName: Name): void;
-    protected emitUnion(u: UnionType, unionName: Name): void;
-    private emitBlock;
-    private emitMappingBlock;
-    private emitClassMembers;
-    private emitInformationComment;
-    private emitTopLevelTypedef;
-    private emitTopLevelConverter;
-    private emitEncodingFunction;
-    private emitDecodingFunction;
-}

package/dist/quicktype-core/language/Pike.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PikeRenderer = exports.PikeTargetLanguage = exports.pikeOptions = void 0;
-const ConvenienceRenderer_1 = require("../ConvenienceRenderer");
-const Naming_1 = require("../Naming");
-const Source_1 = require("../Source");
-const TargetLanguage_1 = require("../TargetLanguage");
-const Type_1 = require("../Type");
-const TypeUtils_1 = require("../TypeUtils");
-const Strings_1 = require("../support/Strings");
-exports.pikeOptions = {};
-const keywords = [
-    "auto",
-    "nomask",
-    "final",
-    "static",
-    "extern",
-    "private",
-    "local",
-    "public",
-    "protected",
-    "inline",
-    "optional",
-    "variant",
-    "void",
-    "mixed",
-    "array",
-    "__attribute__",
-    "__deprecated__",
-    "mapping",
-    "multiset",
-    "object",
-    "function",
-    "__func__",
-    "program",
-    "string",
-    "float",
-    "int",
-    "enum",
-    "typedef",
-    "if",
-    "do",
-    "for",
-    "while",
-    "else",
-    "foreach",
-    "catch",
-    "gauge",
-    "class",
-    "break",
-    "case",
-    "const",
-    "constant",
-    "continue",
-    "default",
-    "import",
-    "inherit",
-    "lambda",
-    "predef",
-    "return",
-    "sscanf",
-    "switch",
-    "typeof",
-    "global"
-];
-const legalizeName = (0, Strings_1.legalizeCharacters)(Strings_1.isLetterOrUnderscoreOrDigit);
-const enumNamingFunction = (0, Naming_1.funPrefixNamer)("enumNamer", (0, Strings_1.makeNameStyle)("upper-underscore", legalizeName));
-const namingFunction = (0, Naming_1.funPrefixNamer)("genericNamer", (0, Strings_1.makeNameStyle)("underscore", legalizeName));
-const namedTypeNamingFunction = (0, Naming_1.funPrefixNamer)("typeNamer", (0, Strings_1.makeNameStyle)("pascal", legalizeName));
-class PikeTargetLanguage extends TargetLanguage_1.TargetLanguage {
-    constructor() {
-        super("Pike", ["pike", "pikelang"], "pmod");
-    }
-    getOptions() {
-        return [];
-    }
-    makeRenderer(renderContext) {
-        return new PikeRenderer(this, renderContext);
-    }
-}
-exports.PikeTargetLanguage = PikeTargetLanguage;
-class PikeRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
-    emitSourceStructure() {
-        this.emitInformationComment();
-        this.ensureBlankLine();
-        this.forEachTopLevel("leading", (t, name) => {
-            this.emitTopLevelTypedef(t, name);
-            this.ensureBlankLine();
-            this.emitTopLevelConverter(t, name);
-            this.ensureBlankLine();
-        }, t => this.namedTypeToNameForTopLevel(t) === undefined);
-        this.ensureBlankLine();
-        this.forEachNamedType("leading-and-interposing", (c, className) => this.emitClassDefinition(c, className), (e, n) => this.emitEnum(e, n), (u, n) => this.emitUnion(u, n));
-    }
-    get enumCasesInGlobalNamespace() {
-        return true;
-    }
-    makeEnumCaseNamer() {
-        return enumNamingFunction;
-    }
-    makeNamedTypeNamer() {
-        return namedTypeNamingFunction;
-    }
-    makeUnionMemberNamer() {
-        return namingFunction;
-    }
-    namerForObjectProperty() {
-        return namingFunction;
-    }
-    forbiddenNamesForGlobalNamespace() {
-        return [...keywords];
-    }
-    forbiddenForObjectProperties(_c, _className) {
-        return { names: [], includeGlobalForbidden: true };
-    }
-    forbiddenForEnumCases(_e, _enumName) {
-        return { names: [], includeGlobalForbidden: true };
-    }
-    forbiddenForUnionMembers(_u, _unionName) {
-        return { names: [], includeGlobalForbidden: true };
-    }
-    sourceFor(t) {
-        if (["class", "object", "enum"].indexOf(t.kind) >= 0) {
-            return (0, Source_1.singleWord)(this.nameForNamedType(t));
-        }
-        return (0, TypeUtils_1.matchType)(t, _anyType => (0, Source_1.singleWord)("mixed"), _nullType => (0, Source_1.singleWord)("mixed"), _boolType => (0, Source_1.singleWord)("bool"), _integerType => (0, Source_1.singleWord)("int"), _doubleType => (0, Source_1.singleWord)("float"), _stringType => (0, Source_1.singleWord)("string"), arrayType => (0, Source_1.singleWord)(["array(", this.sourceFor(arrayType.items).source, ")"]), _classType => (0, Source_1.singleWord)(this.nameForNamedType(_classType)), mapType => {
-            let valueSource;
-            const v = mapType.values;
-            valueSource = this.sourceFor(v).source;
-            return (0, Source_1.singleWord)(["mapping(string:", valueSource, ")"]);
-        }, _enumType => (0, Source_1.singleWord)("enum"), unionType => {
-            if ((0, TypeUtils_1.nullableFromUnion)(unionType) !== null) {
-                const children = Array.from(unionType.getChildren()).map(c => (0, Source_1.parenIfNeeded)(this.sourceFor(c)));
-                return (0, Source_1.multiWord)("|", ...children);
-            }
-            else {
-                return (0, Source_1.singleWord)(this.nameForNamedType(unionType));
-            }
-        });
-    }
-    emitClassDefinition(c, className) {
-        this.emitDescription(this.descriptionForType(c));
-        this.emitBlock(["class ", className], () => {
-            this.emitClassMembers(c);
-            this.ensureBlankLine();
-            this.emitEncodingFunction(c);
-        });
-        this.ensureBlankLine();
-        this.emitDecodingFunction(className, c);
-    }
-    emitEnum(e, enumName) {
-        this.emitBlock([e.kind, " ", enumName], () => {
-            let table = [];
-            this.forEachEnumCase(e, "none", (name, jsonName) => {
-                table.push([
-                    [name, ' = "', (0, Strings_1.stringEscape)(jsonName), '", '],
-                    ['// json: "', jsonName, '"']
-                ]);
-            });
-            this.emitTable(table);
-        });
-    }
-    emitUnion(u, unionName) {
-        const isMaybeWithSingleType = (0, TypeUtils_1.nullableFromUnion)(u);
-        if (isMaybeWithSingleType !== null) {
-            return;
-        }
-        this.emitDescription(this.descriptionForType(u));
-        const [, nonNulls] = (0, TypeUtils_1.removeNullFromUnion)(u);
-        let types = [];
-        this.forEachUnionMember(u, nonNulls, "none", null, (_name, t) => {
-            const pikeType = this.sourceFor(t).source;
-            types.push([pikeType]);
-        });
-        this.emitLine([
-            "typedef ",
-            types.map(r => r.map(sl => this.sourcelikeToString(sl))).join("|"),
-            " ",
-            unionName,
-            ";"
-        ]);
-        this.ensureBlankLine();
-        this.emitBlock([unionName, " ", unionName, "_from_JSON(mixed json)"], () => {
-            this.emitLine(["return json;"]);
-        });
-    }
-    emitBlock(line, f, opening = " {", closing = "}") {
-        this.emitLine(line, opening);
-        this.indent(f);
-        this.emitLine(closing);
-    }
-    emitMappingBlock(line, f) {
-        this.emitBlock(line, f, "([", "]);");
-    }
-    emitClassMembers(c) {
-        let table = [];
-        this.forEachClassProperty(c, "none", (name, jsonName, p) => {
-            const pikeType = this.sourceFor(p.type).source;
-            table.push([
-                [pikeType, " "],
-                [name, "; "],
-                ['// json: "', jsonName, '"']
-            ]);
-        });
-        this.emitTable(table);
-    }
-    emitInformationComment() {
-        this.emitCommentLines([
-            "This source has been automatically generated by quicktype.",
-            "( https://github.com/quicktype/quicktype )",
-            "",
-            "To use this code, simply import it into your project as a Pike module.",
-            "To JSON-encode your object, you can pass it to `Standards.JSON.encode`",
-            "or call `encode_json` on it.",
-            "",
-            "To decode a JSON string, first pass it to `Standards.JSON.decode`,",
-            "and then pass the result to `<YourClass>_from_JSON`.",
-            "It will return an instance of <YourClass>.",
-            "Bear in mind that these functions have unexpected behavior,",
-            "and will likely throw an error, if the JSON string does not",
-            "match the expected interface, even if the JSON itself is valid."
-        ], "// ");
-    }
-    emitTopLevelTypedef(t, name) {
-        this.emitLine("typedef ", this.sourceFor(t).source, " ", name, ";");
-    }
-    emitTopLevelConverter(t, name) {
-        this.emitBlock([name, " ", name, "_from_JSON(mixed json)"], () => {
-            if (t instanceof Type_1.PrimitiveType) {
-                this.emitLine(["return json;"]);
-            }
-            else if (t instanceof Type_1.ArrayType) {
-                if (t.items instanceof Type_1.PrimitiveType)
-                    this.emitLine(["return json;"]);
-                else
-                    this.emitLine(["return map(json, ", this.sourceFor(t.items).source, "_from_JSON);"]);
-            }
-            else if (t instanceof Type_1.MapType) {
-                const type = this.sourceFor(t.values).source;
-                this.emitLine(["mapping(string:", type, ") retval = ([]);"]);
-                let assignmentRval;
-                if (t.values instanceof Type_1.PrimitiveType)
-                    assignmentRval = ["(", type, ") v"];
-                else
-                    assignmentRval = [type, "_from_JSON(v)"];
-                this.emitBlock(["foreach (json; string k; mixed v)"], () => {
-                    this.emitLine(["retval[k] = ", assignmentRval, ";"]);
-                });
-                this.emitLine(["return retval;"]);
-            }
-        });
-    }
-    emitEncodingFunction(c) {
-        this.emitBlock(["string encode_json()"], () => {
-            this.emitMappingBlock(["mapping(string:mixed) json = "], () => {
-                this.forEachClassProperty(c, "none", (name, jsonName) => {
-                    this.emitLine(['"', (0, Strings_1.stringEscape)(jsonName), '" : ', name, ","]);
-                });
-            });
-            this.ensureBlankLine();
-            this.emitLine(["return Standards.JSON.encode(json);"]);
-        });
-    }
-    emitDecodingFunction(className, c) {
-        this.emitBlock([className, " ", className, "_from_JSON(mixed json)"], () => {
-            this.emitLine([className, " retval = ", className, "();"]);
-            this.ensureBlankLine();
-            this.forEachClassProperty(c, "none", (name, jsonName) => {
-                this.emitLine(["retval.", name, ' = json["', (0, Strings_1.stringEscape)(jsonName), '"];']);
-            });
-            this.ensureBlankLine();
-            this.emitLine(["return retval;"]);
-        });
-    }
-}
-exports.PikeRenderer = PikeRenderer;

package/dist/quicktype-core/language/Python.d.ts

@@ -1,107 +0,0 @@
-import { TargetLanguage } from "../TargetLanguage";
-import { StringTypeMapping } from "../TypeBuilder";
-import { Type, EnumType, ClassType, ClassProperty } from "../Type";
-import { RenderContext } from "../Renderer";
-import { Option, OptionValues, EnumOption, BooleanOption } from "../RendererOptions";
-import { ConvenienceRenderer, ForbiddenWordsInfo } from "../ConvenienceRenderer";
-import { Namer, Name, DependencyName } from "../Naming";
-import { Sourcelike, MultiWord } from "../Source";
-import { Transformer } from "../Transformers";
-export type PythonFeatures = {
-    typeHints: boolean;
-    dataClasses: boolean;
-};
-export declare const pythonOptions: {
-    features: EnumOption<PythonFeatures>;
-    justTypes: BooleanOption;
-    nicePropertyNames: BooleanOption;
-};
-export declare class PythonTargetLanguage extends TargetLanguage {
-    protected getOptions(): Option<any>[];
-    get stringTypeMapping(): StringTypeMapping;
-    get supportsUnionsWithBothNumberTypes(): boolean;
-    get supportsOptionalClassProperties(): boolean;
-    needsTransformerForType(t: Type): boolean;
-    protected makeRenderer(renderContext: RenderContext, untypedOptionValues: {
-        [name: string]: any;
-    }): PythonRenderer;
-}
-export declare class PythonRenderer extends ConvenienceRenderer {
-    protected readonly pyOptions: OptionValues<typeof pythonOptions>;
-    private readonly imports;
-    private readonly declaredTypes;
-    constructor(targetLanguage: TargetLanguage, renderContext: RenderContext, pyOptions: OptionValues<typeof pythonOptions>);
-    protected forbiddenNamesForGlobalNamespace(): string[];
-    protected forbiddenForObjectProperties(_: ClassType, _classNamed: Name): ForbiddenWordsInfo;
-    protected makeNamedTypeNamer(): Namer;
-    protected namerForObjectProperty(): Namer;
-    protected makeUnionMemberNamer(): null;
-    protected makeEnumCaseNamer(): Namer;
-    protected get commentLineStart(): string;
-    protected emitDescriptionBlock(lines: Sourcelike[]): void;
-    protected get needsTypeDeclarationBeforeUse(): boolean;
-    protected canBeForwardDeclared(t: Type): boolean;
-    protected emitBlock(line: Sourcelike, f: () => void): void;
-    protected string(s: string): Sourcelike;
-    protected withImport(module: string, name: string): Sourcelike;
-    protected withTyping(name: string): Sourcelike;
-    protected namedType(t: Type): Sourcelike;
-    protected pythonType(t: Type): Sourcelike;
-    protected declarationLine(t: Type): Sourcelike;
-    protected declareType<T extends Type>(t: T, emitter: () => void): void;
-    protected emitClassMembers(t: ClassType): void;
-    protected typeHint(...sl: Sourcelike[]): Sourcelike;
-    protected typingDecl(name: Sourcelike, type: string): Sourcelike;
-    protected typingReturn(type: string): Sourcelike;
-    protected sortClassProperties(properties: ReadonlyMap<string, ClassProperty>, propertyNames: ReadonlyMap<string, Name>): ReadonlyMap<string, ClassProperty>;
-    protected emitClass(t: ClassType): void;
-    protected emitEnum(t: EnumType): void;
-    protected emitImports(): void;
-    protected emitSupportCode(): void;
-    protected emitClosingCode(): void;
-    protected emitSourceStructure(_givenOutputFilename: string): void;
-}
-export type ConverterFunction = "none" | "bool" | "int" | "from-float" | "to-float" | "str" | "to-enum" | "list" | "to-class" | "dict" | "union" | "from-datetime" | "from-stringified-bool" | "is-type";
-export type ValueOrLambda = {
-    value: Sourcelike | undefined;
-    lambda?: MultiWord;
-};
-export declare class JSONPythonRenderer extends PythonRenderer {
-    private readonly _deserializerFunctions;
-    private readonly _converterNamer;
-    private readonly _topLevelConverterNames;
-    private _haveTypeVar;
-    private _haveEnumTypeVar;
-    private _haveDateutil;
-    protected emitTypeVar(tvar: string, constraints: Sourcelike): void;
-    protected typeVar(): string;
-    protected enumTypeVar(): string;
-    protected cast(type: Sourcelike, v: Sourcelike): Sourcelike;
-    protected emitNoneConverter(): void;
-    protected emitBoolConverter(): void;
-    protected emitIntConverter(): void;
-    protected emitFromFloatConverter(): void;
-    protected emitToFloatConverter(): void;
-    protected emitStrConverter(): void;
-    protected emitToEnumConverter(): void;
-    protected emitListConverter(): void;
-    protected emitToClassConverter(): void;
-    protected emitDictConverter(): void;
-    protected emitUnionConverter(): void;
-    protected emitFromDatetimeConverter(): void;
-    protected emitFromStringifiedBoolConverter(): void;
-    protected emitIsTypeConverter(): void;
-    protected emitConverter(cf: ConverterFunction): void;
-    protected conv(cf: ConverterFunction): Sourcelike;
-    protected convFn(cf: ConverterFunction, arg: ValueOrLambda): ValueOrLambda;
-    protected typeObject(t: Type): Sourcelike;
-    protected transformer(inputTransformer: ValueOrLambda, xfer: Transformer, targetType: Type): ValueOrLambda;
-    protected deserializer(value: ValueOrLambda, t: Type): ValueOrLambda;
-    protected serializer(value: ValueOrLambda, t: Type): ValueOrLambda;
-    protected emitClassMembers(t: ClassType): void;
-    protected emitImports(): void;
-    protected emitSupportCode(): void;
-    protected makeTopLevelDependencyNames(_t: Type, topLevelName: Name): DependencyName[];
-    protected emitDefaultLeadingComments(): void;
-    protected emitClosingCode(): void;
-}