quicktype 17.0.1 → 17.0.3

package/dist/quicktype-core/GatherNames.js

@@ -1,6 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const pluralize = require("pluralize");
+exports.gatherNames = void 0;
+const pluralize = __importStar(require("pluralize"));
 const collection_utils_1 = require("collection-utils");
 const Type_1 = require("./Type");
 const TypeUtils_1 = require("./TypeUtils");
@@ -8,11 +32,9 @@ const TypeNames_1 = require("./attributes/TypeNames");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
 class UniqueQueue {
-    constructor() {
-        this._present = new Set();
-        this._queue = [];
-        this._front = 0;
-    }
+    _present = new Set();
+    _queue = [];
+    _front = 0;
     get size() {
         return this._queue.length - this._front;
     }
@@ -26,10 +48,10 @@ class UniqueQueue {
         this._present.add(v);
     }
     unshift() {
-        Support_1.assert(!this.isEmpty, "Trying to unshift from an empty queue");
+        (0, Support_1.assert)(!this.isEmpty, "Trying to unshift from an empty queue");
         const v = this._queue[this._front];
         if (v === undefined) {
-            return Support_1.panic("Value should have been present in queue");
+            return (0, Support_1.panic)("Value should have been present in queue");
         }
         this._queue[this._front] = undefined;
         this._front += 1;
@@ -109,13 +131,13 @@ function gatherNames(graph, destructive, debugPrint) {
             newNames = null;
         }
         else {
-            newNames = collection_utils_1.setUnion(oldNames, names);
+            newNames = (0, collection_utils_1.setUnion)(oldNames, names);
         }
         if (newNames !== null && newNames.size >= TypeNames_1.tooManyNamesThreshold) {
             newNames = null;
         }
         namesForType.set(t, newNames);
-        const transformation = Transformers_1.transformationForType(t);
+        const transformation = (0, Transformers_1.transformationForType)(t);
         if (transformation !== undefined) {
             addNames(transformation.targetType, names);
         }
@@ -134,7 +156,7 @@ function gatherNames(graph, destructive, debugPrint) {
     }
     while (!queue.isEmpty) {
         const t = queue.unshift();
-        const names = Support_1.defined(namesForType.get(t));
+        const names = (0, Support_1.defined)(namesForType.get(t));
         if (t instanceof Type_1.ObjectType) {
             const properties = t.getSortedProperties();
             for (const [propertyName, property] of properties) {
@@ -142,14 +164,14 @@ function gatherNames(graph, destructive, debugPrint) {
             }
             const values = t.getAdditionalProperties();
             if (values !== undefined) {
-                addNames(values, names === null ? null : collection_utils_1.setMap(names, pluralize.singular));
+                addNames(values, names === null ? null : (0, collection_utils_1.setMap)(names, pluralize.singular));
             }
         }
         else {
-            TypeUtils_1.matchCompoundType(t, arrayType => {
-                addNames(arrayType.items, names === null ? null : collection_utils_1.setMap(names, pluralize.singular));
-            }, _classType => Support_1.panic("We handled this above"), _mapType => Support_1.panic("We handled this above"), _objectType => Support_1.panic("We handled this above"), unionType => {
-                const members = collection_utils_1.setSortBy(unionType.members, member => member.kind);
+            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
+                addNames(arrayType.items, names === null ? null : (0, collection_utils_1.setMap)(names, pluralize.singular));
+            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
+                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
                 for (const memberType of members) {
                     addNames(memberType, names);
                 }
@@ -176,14 +198,14 @@ function gatherNames(graph, destructive, debugPrint) {
         if (existing === undefined) {
             existing = new Set();
         }
-        existing = collection_utils_1.setUnion(existing, alternatives);
+        existing = (0, collection_utils_1.setUnion)(existing, alternatives);
         if (existing.size < TypeNames_1.tooManyNamesThreshold) {
             return existing;
         }
         return null;
     }
     function processType(ancestor, t, alternativeSuffix) {
-        const names = Support_1.defined(namesForType.get(t));
+        const names = (0, Support_1.defined)(namesForType.get(t));
         let processedEntry = pairsProcessed.get(ancestor);
         if (processedEntry === undefined)
             processedEntry = new Set();
@@ -191,7 +213,7 @@ function gatherNames(graph, destructive, debugPrint) {
             return;
         processedEntry.add(t);
         pairsProcessed.set(ancestor, processedEntry);
-        const transformation = Transformers_1.transformationForType(t);
+        const transformation = (0, Transformers_1.transformationForType)(t);
         if (transformation !== undefined) {
             processType(ancestor, transformation.targetType, alternativeSuffix);
         }
@@ -244,12 +266,12 @@ function gatherNames(graph, destructive, debugPrint) {
             }
         }
         else {
-            TypeUtils_1.matchCompoundType(t, arrayType => {
+            (0, TypeUtils_1.matchCompoundType)(t, arrayType => {
                 processType(ancestor, arrayType.items, "element");
-            }, _classType => Support_1.panic("We handled this above"), _mapType => Support_1.panic("We handled this above"), _objectType => Support_1.panic("We handled this above"), unionType => {
-                const members = collection_utils_1.setSortBy(unionType.members, member => member.kind);
+            }, _classType => (0, Support_1.panic)("We handled this above"), _mapType => (0, Support_1.panic)("We handled this above"), _objectType => (0, Support_1.panic)("We handled this above"), unionType => {
+                const members = (0, collection_utils_1.setSortBy)(unionType.members, member => member.kind);
                 const unionHasGivenName = unionType.hasNames && !unionType.getNames().areInferred;
-                const unionIsAncestor = unionHasGivenName || TypeUtils_1.nullableFromUnion(unionType) === null;
+                const unionIsAncestor = unionHasGivenName || (0, TypeUtils_1.nullableFromUnion)(unionType) === null;
                 const ancestorForMembers = unionIsAncestor ? unionType : ancestor;
                 for (const memberType of members) {
                     processType(ancestorForMembers, memberType, undefined);
@@ -274,7 +296,7 @@ function gatherNames(graph, destructive, debugPrint) {
         if (alternatives === undefined) {
             alternatives = new Set();
         }
-        alternatives = collection_utils_1.setUnion(alternatives, collection_utils_1.setMap(names, name => `${name}_${t.kind}`));
+        alternatives = (0, collection_utils_1.setUnion)(alternatives, (0, collection_utils_1.setMap)(names, name => `${name}_${t.kind}`));
         directAlternativesForType.set(t, alternatives);
     }
     for (const t of graph.allTypesUnordered()) {
@@ -300,7 +322,7 @@ function gatherNames(graph, destructive, debugPrint) {
                     alternatives = new Set();
                 }
                 if (ancestorAlternatives !== null && ancestorAlternatives !== undefined) {
-                    alternatives = collection_utils_1.setUnion(alternatives, ancestorAlternatives);
+                    alternatives = (0, collection_utils_1.setUnion)(alternatives, ancestorAlternatives);
                 }
             }
             typeNames = TypeNames_1.TypeNames.makeWithDistance(names, alternatives, destructive ? 1 : 10);

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

@@ -3,8 +3,8 @@ export declare class Graph<T> {
     private readonly _indexByNode;
     private readonly _successors;
     constructor(nodes: Iterable<T>, invertDirection: boolean, edges: number[][] | ((node: T) => ReadonlySet<T>));
-    readonly size: number;
-    readonly nodes: ReadonlyArray<T>;
+    get size(): number;
+    get nodes(): ReadonlyArray<T>;
     findRoots(): ReadonlySet<T>;
     dfsTraversal(root: T, preOrder: boolean, process: (node: T) => void): void;
     stronglyConnectedComponents(): Graph<ReadonlySet<T>>;

package/dist/quicktype-core/Graph.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graph = void 0;
 const collection_utils_1 = require("collection-utils");
 const Support_1 = require("./support/Support");
 function countComponentGraphNodes(components) {
@@ -8,14 +9,14 @@ function countComponentGraphNodes(components) {
     let largest = -1;
     let count = 0;
     for (const c of components) {
-        Support_1.assert(c.length > 0, "Empty component not allowed");
+        (0, Support_1.assert)(c.length > 0, "Empty component not allowed");
         for (const v of c) {
-            Support_1.assert(v >= 0, "Negative vertex index is invalid");
+            (0, Support_1.assert)(v >= 0, "Negative vertex index is invalid");
             largest = Math.max(largest, v);
             count += 1;
         }
     }
-    Support_1.assert(largest + 1 === count, "Vertex indexes and count don't match up");
+    (0, Support_1.assert)(largest + 1 === count, "Vertex indexes and count don't match up");
     return count;
 }
 // https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
@@ -23,9 +24,9 @@ function stronglyConnectedComponents(successors) {
     let index = 0;
     const stack = [];
     const numNodes = successors.length;
-    const indexes = Support_1.repeated(numNodes, -1);
-    const lowLinks = Support_1.repeated(numNodes, -1);
-    const onStack = Support_1.repeated(numNodes, false);
+    const indexes = (0, Support_1.repeated)(numNodes, -1);
+    const lowLinks = (0, Support_1.repeated)(numNodes, -1);
+    const onStack = (0, Support_1.repeated)(numNodes, false);
     const sccs = [];
     function strongconnect(v) {
         // Set the depth index for v to the smallest unused index
@@ -54,7 +55,7 @@ function stronglyConnectedComponents(successors) {
             const scc = [];
             let w;
             do {
-                w = Support_1.defined(stack.pop());
+                w = (0, Support_1.defined)(stack.pop());
                 onStack[w] = false;
                 scc.push(w);
             } while (w !== v);
@@ -66,17 +67,17 @@ function stronglyConnectedComponents(successors) {
             strongconnect(v);
         }
     }
-    Support_1.assert(countComponentGraphNodes(sccs) === numNodes, "We didn't put all the nodes into SCCs");
+    (0, Support_1.assert)(countComponentGraphNodes(sccs) === numNodes, "We didn't put all the nodes into SCCs");
     return sccs;
 }
 function buildComponentOfNodeMap(successors, components) {
     const numComponents = components.length;
     const numNodes = successors.length;
-    Support_1.assert(numNodes === countComponentGraphNodes(components), "Components don't match up with graph");
-    const componentOfNode = Support_1.repeated(numNodes, -1);
+    (0, Support_1.assert)(numNodes === countComponentGraphNodes(components), "Components don't match up with graph");
+    const componentOfNode = (0, Support_1.repeated)(numNodes, -1);
     for (let c = 0; c < numComponents; c++) {
         for (const n of components[c]) {
-            Support_1.assert(componentOfNode[n] < 0, "We have a node that's in two components");
+            (0, Support_1.assert)(componentOfNode[n] < 0, "We have a node that's in two components");
             componentOfNode[n] = c;
         }
     }
@@ -85,7 +86,7 @@ function buildComponentOfNodeMap(successors, components) {
 function buildMetaSuccessors(successors, components) {
     const numComponents = components.length;
     const componentOfNode = buildComponentOfNodeMap(successors, components);
-    const componentAdded = Support_1.repeated(numComponents, false);
+    const componentAdded = (0, Support_1.repeated)(numComponents, false);
     const metaSuccessors = [];
     for (let c = 0; c < numComponents; c++) {
         const succ = [];
@@ -100,7 +101,7 @@ function buildMetaSuccessors(successors, components) {
         }
         // reset bookkeeping
         for (const ms of succ) {
-            Support_1.assert(componentAdded[ms]);
+            (0, Support_1.assert)(componentAdded[ms]);
             componentAdded[ms] = false;
         }
         metaSuccessors.push(succ);
@@ -109,7 +110,7 @@ function buildMetaSuccessors(successors, components) {
 }
 function invertEdges(successors) {
     const numNodes = successors.length;
-    const predecessors = Support_1.repeatedCall(numNodes, () => []);
+    const predecessors = (0, Support_1.repeatedCall)(numNodes, () => []);
     for (let s = 0; s < numNodes; s++) {
         for (const v of successors[s]) {
             predecessors[v].push(s);
@@ -119,7 +120,7 @@ function invertEdges(successors) {
 }
 function calculateInDegrees(successors) {
     const numNodes = successors.length;
-    const inDegrees = Support_1.repeated(numNodes, 0);
+    const inDegrees = (0, Support_1.repeated)(numNodes, 0);
     for (const s of successors) {
         for (const v of s) {
             inDegrees[v] += 1;
@@ -139,6 +140,9 @@ function findRoots(successors) {
     return roots;
 }
 class Graph {
+    _nodes;
+    _indexByNode;
+    _successors;
     constructor(nodes, invertDirection, edges) {
         this._nodes = Array.from(nodes);
         this._indexByNode = new Map(this._nodes.map((n, i) => [n, i]));
@@ -147,7 +151,7 @@ class Graph {
             edgesArray = edges;
         }
         else {
-            edgesArray = this._nodes.map(n => Array.from(edges(n)).map(s => Support_1.defined(this._indexByNode.get(s))));
+            edgesArray = this._nodes.map(n => Array.from(edges(n)).map(s => (0, Support_1.defined)(this._indexByNode.get(s))));
         }
         if (invertDirection) {
             edgesArray = invertEdges(edgesArray);
@@ -166,7 +170,7 @@ class Graph {
     }
     // The subgraph starting at `root` must be acyclic.
     dfsTraversal(root, preOrder, process) {
-        const visited = Support_1.repeated(this.size, false);
+        const visited = (0, Support_1.repeated)(this.size, false);
         const visit = (v) => {
             if (visited[v])
                 return;
@@ -181,12 +185,12 @@ class Graph {
                 process(this._nodes[v]);
             }
         };
-        visit(Support_1.defined(this._indexByNode.get(root)));
+        visit((0, Support_1.defined)(this._indexByNode.get(root)));
     }
     stronglyConnectedComponents() {
         const components = stronglyConnectedComponents(this._successors);
         const componentSuccessors = buildMetaSuccessors(this._successors, components);
-        return new Graph(components.map(ns => collection_utils_1.setMap(ns, n => this._nodes[n])), false, componentSuccessors);
+        return new Graph(components.map(ns => (0, collection_utils_1.setMap)(ns, n => this._nodes[n])), false, componentSuccessors);
     }
     makeDot(includeNode, nodeLabel) {
         const lines = [];

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

@@ -60,10 +60,10 @@ export declare abstract class BaseGraphRewriteBuilder extends TypeBuilder implem
     reconstituteTypeAttributes(attributes: TypeAttributes): TypeAttributes;
     protected assertTypeRefsToReconstitute(typeRefs: TypeRef[], forwardingRef?: TypeRef): void;
     protected changeDebugPrintIndent(delta: number): void;
-    protected readonly debugPrintIndentation: string;
+    protected get debugPrintIndentation(): string;
     finish(): TypeGraph;
     setLostTypeAttributes(): void;
-    readonly lostTypeAttributes: boolean;
+    get lostTypeAttributes(): boolean;
 }
 export declare class GraphRemapBuilder extends BaseGraphRewriteBuilder {
     private readonly _map;