quicktype 18.0.6 → 19.0.5

package/dist/quicktype-core/DateTime.js

@@ -1,57 +0,0 @@
-"use strict";
-// https://github.com/epoberezkin/ajv/blob/4d76c6fb813b136b6ec4fe74990bc97233d75dea/lib/compile/formats.js
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultDateTimeRecognizer = void 0;
-/*
-The MIT License (MIT)
-
-Copyright (c) 2015 Evgeny Poberezkin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-const DAYS = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-const TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d:\d\d)?$/i;
-const DATE_TIME_SEPARATOR = /t|\s/i;
-class DefaultDateTimeRecognizer {
-    isDate(str) {
-        // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
-        const matches = str.match(DATE);
-        if (matches === null)
-            return false;
-        const month = +matches[2];
-        const day = +matches[3];
-        return month >= 1 && month <= 12 && day >= 1 && day <= DAYS[month];
-    }
-    isTime(str) {
-        const matches = str.match(TIME);
-        if (matches === null)
-            return false;
-        const hour = +matches[1];
-        const minute = +matches[2];
-        const second = +matches[3];
-        return hour <= 23 && minute <= 59 && second <= 59;
-    }
-    isDateTime(str) {
-        // http://tools.ietf.org/html/rfc3339#section-5.6
-        const dateTime = str.split(DATE_TIME_SEPARATOR);
-        return dateTime.length === 2 && this.isDate(dateTime[0]) && this.isTime(dateTime[1]);
-    }
-}
-exports.DefaultDateTimeRecognizer = DefaultDateTimeRecognizer;

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

@@ -1,14 +0,0 @@
-import { TypeGraph } from "./TypeGraph";
-import { Type } from "./Type";
-export type DeclarationKind = "forward" | "define";
-export interface Declaration {
-    readonly kind: DeclarationKind;
-    readonly type: Type;
-}
-export declare class DeclarationIR {
-    readonly forwardedTypes: Set<Type>;
-    readonly declarations: ReadonlyArray<Declaration>;
-    constructor(declarations: Iterable<Declaration>, forwardedTypes: Set<Type>);
-}
-export declare function cycleBreakerTypesForGraph(graph: TypeGraph, isImplicitCycleBreaker: (t: Type) => boolean, canBreakCycles: (t: Type) => boolean): Set<Type>;
-export declare function declarationsForGraph(typeGraph: TypeGraph, canBeForwardDeclared: ((t: Type) => boolean) | undefined, childrenOfType: (t: Type) => ReadonlySet<Type>, needsDeclaration: (t: Type) => boolean): DeclarationIR;

package/dist/quicktype-core/DeclarationIR.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.declarationsForGraph = exports.cycleBreakerTypesForGraph = exports.DeclarationIR = void 0;
-const collection_utils_1 = require("collection-utils");
-const Support_1 = require("./support/Support");
-const Graph_1 = require("./Graph");
-const Messages_1 = require("./Messages");
-class DeclarationIR {
-    forwardedTypes;
-    declarations;
-    constructor(declarations, forwardedTypes) {
-        this.forwardedTypes = forwardedTypes;
-        this.declarations = Array.from(declarations);
-    }
-}
-exports.DeclarationIR = DeclarationIR;
-function findBreaker(t, path, canBreak) {
-    const index = path.indexOf(t);
-    if (index < 0)
-        return undefined;
-    if (canBreak === undefined) {
-        return path[index];
-    }
-    const potentialBreakers = path.slice(0, index + 1).reverse();
-    const maybeBreaker = potentialBreakers.find(canBreak);
-    if (maybeBreaker === undefined) {
-        return (0, Support_1.panic)("Found a cycle that cannot be broken");
-    }
-    return maybeBreaker;
-}
-function cycleBreakerTypesForGraph(graph, isImplicitCycleBreaker, canBreakCycles) {
-    const visitedTypes = new Set();
-    const cycleBreakerTypes = new Set();
-    const queue = Array.from(graph.topLevels.values());
-    function visit(t, path) {
-        if (visitedTypes.has(t))
-            return;
-        if (isImplicitCycleBreaker(t)) {
-            for (const c of t.getChildren()) {
-                queue.push(c);
-            }
-        }
-        else {
-            const maybeBreaker = findBreaker(t, path, canBreakCycles);
-            if (maybeBreaker !== undefined) {
-                cycleBreakerTypes.add(maybeBreaker);
-                return;
-            }
-            for (const c of t.getChildren()) {
-                path.unshift(t);
-                visit(c, path);
-                path.shift();
-            }
-        }
-        visitedTypes.add(t);
-    }
-    for (;;) {
-        const maybeType = queue.pop();
-        if (maybeType === undefined)
-            break;
-        const path = [];
-        visit(maybeType, path);
-        (0, Support_1.assert)(path.length === 0);
-    }
-    return cycleBreakerTypes;
-}
-exports.cycleBreakerTypesForGraph = cycleBreakerTypesForGraph;
-function declarationsForGraph(typeGraph, canBeForwardDeclared, childrenOfType, needsDeclaration) {
-    /*
-    function nodeTitle(t: Type): string {
-        const indexAndKind = `${t.typeRef.index} ${t.kind}`;
-        if (t.hasNames) {
-            return `${indexAndKind} ${t.getCombinedName()}`;
-        } else {
-            return indexAndKind;
-        }
-    }
-    function componentName(c: Iterable<Type>): string {
-        return Array.from(c).map(nodeTitle).join(", ");
-    }
-    */
-    const topDown = canBeForwardDeclared === undefined;
-    const declarations = [];
-    const forwardedTypes = new Set();
-    const visitedComponents = new Set();
-    function processGraph(graph, _writeComponents) {
-        const componentsGraph = graph.stronglyConnectedComponents();
-        function visitComponent(component) {
-            if (visitedComponents.has(component))
-                return;
-            visitedComponents.add(component);
-            // console.log(`visiting component ${componentName(component)}`);
-            const declarationNeeded = (0, collection_utils_1.setFilter)(component, needsDeclaration);
-            // 1. Only one node in the cycle needs a declaration, in which
-            // case it's the breaker, and no forward declaration is necessary.
-            if (declarationNeeded.size === 1) {
-                declarations.push({ kind: "define", type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(declarationNeeded)) });
-                return;
-            }
-            // 2. No node in the cycle needs a declaration, but it's also
-            // the only node, so we don't actually need a declaration at all.
-            if (declarationNeeded.size === 0 && component.size === 1) {
-                return;
-            }
-            // 3. No node in the cycle needs a declaration, but there's more.
-            // than one node total.  We have to pick a node to make a
-            // declaration, so we can pick any one. This is not a forward
-            // declaration, either.
-            if (declarationNeeded.size === 0) {
-                declarations.push({ kind: "define", type: (0, Support_1.defined)((0, collection_utils_1.iterableFirst)(component)) });
-                return;
-            }
-            // 4. More than one node needs a declaration, and we don't need
-            // forward declarations.  Just declare all of them and be done
-            // with it.
-            if (canBeForwardDeclared === undefined) {
-                for (const t of declarationNeeded) {
-                    declarations.push({ kind: "define", type: t });
-                }
-                return;
-            }
-            // 5. More than one node needs a declaration, and we have
-            // to make forward declarations.  We do the simple thing and first
-            // forward-declare all forward-declarable types in the SCC.  If
-            // there are none, we're stuck.  If there are, we take them out of
-            // the component and try the whole thing again recursively.  Then
-            // we declare the types we previously forward-declared.
-            const forwardDeclarable = (0, collection_utils_1.setFilter)(component, canBeForwardDeclared);
-            if (forwardDeclarable.size === 0) {
-                return (0, Messages_1.messageError)("IRNoForwardDeclarableTypeInCycle", {});
-            }
-            for (const t of forwardDeclarable) {
-                declarations.push({ kind: "forward", type: t });
-            }
-            (0, collection_utils_1.setUnionInto)(forwardedTypes, forwardDeclarable);
-            const rest = (0, collection_utils_1.setSubtract)(component, forwardDeclarable);
-            const restGraph = new Graph_1.Graph(rest, true, t => (0, collection_utils_1.setIntersect)(childrenOfType(t), rest));
-            processGraph(restGraph, false);
-            for (const t of forwardDeclarable) {
-                declarations.push({ kind: "define", type: t });
-            }
-            return;
-        }
-        /*
-        if (_writeComponents) {
-            componentsGraph.nodes.forEach(types => {
-                console.log(
-                    `scc: ${types
-                        .filter(t => t instanceof ClassType)
-                        .map(t => t.getCombinedName())
-                        .join(", ")}`
-                );
-            });
-        }
-        */
-        const rootsUnordered = componentsGraph.findRoots();
-        const roots = rootsUnordered;
-        for (const component of roots) {
-            componentsGraph.dfsTraversal(component, topDown, visitComponent);
-        }
-    }
-    const fullGraph = typeGraph.makeGraph(false, childrenOfType);
-    // fs.writeFileSync("graph.dot", fullGraph.makeDot(t => !(t instanceof PrimitiveType), nodeTitle));
-    processGraph(fullGraph, true);
-    return new DeclarationIR(declarations, forwardedTypes);
-}
-exports.declarationsForGraph = declarationsForGraph;