quicktype-core 23.3.22 → 23.3.23

package/dist/rewrites/FlattenUnions.js

@@ -11,16 +11,67 @@ const TypeUtils_1 = require("../Type/TypeUtils");
 const UnifyClasses_1 = require("../UnifyClasses");
 function flattenUnions(graph, stringTypeMapping, conflateNumbers, makeObjectTypes, debugPrintReconstitution) {
     let needsRepeat = false;
+    // During flattening, recursive unions can appear again while their replacement
+    // is still being built.  For example, flattening `A | M` can later ask for
+    // `A | (A | M)` through an array item or object property.  Those are the same
+    // union by associativity/idempotence, so remember each in-progress flattened
+    // union by a normalized key of its non-union member refs.  Looking up that key
+    // lets recursive occurrences reuse the replacement's forwarding ref instead
+    // of allocating another finite unrolling of the same cycle.
+    const unionKeyToRef = new Map();
+    function addUnionKeyAtoms(t, atoms, seen) {
+        const index = t.index;
+        if (seen.has(index))
+            return;
+        seen.add(index);
+        if (t instanceof Type_1.UnionType) {
+            for (const m of t.members) {
+                addUnionKeyAtoms(m, atoms, seen);
+            }
+        }
+        else {
+            atoms.add((0, TypeRef_1.typeRefIndex)(t.typeRef));
+        }
+    }
+    function unionKeyForTypes(types) {
+        const atoms = new Set();
+        const seen = new Set();
+        for (const t of types) {
+            addUnionKeyAtoms(t, atoms, seen);
+        }
+        return Array.from(atoms)
+            .sort((a, b) => a - b)
+            .join(",");
+    }
     function replace(types, builder, forwardingRef) {
-        const unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, (trefs) => {
+        unionKeyToRef.set(unionKeyForTypes(types), forwardingRef);
+        let unionBuilder;
+        const unifyTypeRefs = (trefs) => {
             (0, Support_1.assert)(trefs.length > 0, "Must have at least one type to build union");
-            trefs = trefs.map((tref) => builder.reconstituteType((0, TypeRef_1.derefTypeRef)(tref, graph)));
-            if (trefs.length === 1) {
-                return trefs[0];
+            const maybeReconstituted = builder.lookupTypeRefs(trefs, undefined, false);
+            if (maybeReconstituted !== undefined) {
+                return maybeReconstituted;
+            }
+            const typesToUnify = new Set(trefs.map((tref) => (0, TypeRef_1.derefTypeRef)(tref, graph)));
+            if ((0, collection_utils_1.iterableSome)(typesToUnify, (t) => t instanceof Type_1.IntersectionType)) {
+                trefs = trefs.map((tref) => builder.reconstituteType((0, TypeRef_1.derefTypeRef)(tref, graph)));
+                if (trefs.length === 1) {
+                    return trefs[0];
+                }
+                needsRepeat = true;
+                return builder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(trefs));
+            }
+            const key = unionKeyForTypes(typesToUnify);
+            const maybeRef = unionKeyToRef.get(key);
+            if (maybeRef !== undefined) {
+                return maybeRef;
             }
-            needsRepeat = true;
-            return builder.getUnionType(TypeAttributes_1.emptyTypeAttributes, new Set(trefs));
-        });
+            return builder.withForwardingRef(undefined, (nestedForwardingRef) => {
+                unionKeyToRef.set(key, nestedForwardingRef);
+                return (0, UnifyClasses_1.unifyTypes)(typesToUnify, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, nestedForwardingRef);
+            });
+        };
+        unionBuilder = new UnifyClasses_1.UnifyUnionBuilder(builder, makeObjectTypes, true, unifyTypeRefs);
         return (0, UnifyClasses_1.unifyTypes)(types, TypeAttributes_1.emptyTypeAttributes, builder, unionBuilder, conflateNumbers, forwardingRef);
     }
     const allUnions = (0, collection_utils_1.setFilter)(graph.allTypesUnordered(), (t) => t instanceof Type_1.UnionType);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.3.22",
+    "version": "23.3.23",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",