wip: deduplicate inline unions

src/typeEvaluator/optimizations.ts

@@ -1,4 +1,12 @@
-import type {TypeNode} from './types'
+import type {InlineTypeNode, ObjectTypeNode, TypeNode, UnionTypeNode} from './types'
+
+function hashObjectTypeNode(object: ObjectTypeNode, ignoreRest: boolean = false) {
+  return `${object.type}:(${Object.entries(object.attributes)
+    .map(([key, value]) => `${key}:${hashField(value.value)}`)
+    .join(
+      ',',
+    )}):ref-${object.dereferencesTo}:${!ignoreRest && object.rest ? hashField(object.rest) : 'no-rest'}`
+}
 
 export function hashField(field: TypeNode): string {
   switch (field.type) {
@@ -21,9 +29,7 @@ export function hashField(field: TypeNode): string {
     }
 
     case 'object': {
-      return `${field.type}:(${Object.entries(field.attributes)
-        .map(([key, value]) => `${key}:${hashField(value.value)}`)
-        .join(',')}):ref-${field.dereferencesTo}:${field.rest ? hashField(field.rest) : 'no-rest'}`
+      return hashObjectTypeNode(field)
     }
 
     case 'union': {
@@ -66,10 +72,49 @@ export function optimizeUnions(field: TypeNode): TypeNode {
   if (field.type === 'union') {
     field.of = removeDuplicateTypeNodes(field.of)
 
+    // empty union, abort early
+    if (field.of.length === 0) {
+      return field
+    }
+
+    // single element union, optimize
     if (field.of.length === 1) {
       return optimizeUnions(field.of[0])
     }
 
+    //
+    if (field.of[0].type === 'object' && field.of[0].rest?.type === 'inline') {
+      const objectAttributeHash = hashObjectTypeNode(field.of[0], true)
+      if (
+        field.of.every(
+          (node) =>
+            node.type === 'object' &&
+            node.rest?.type === 'inline' &&
+            hashObjectTypeNode(node, true) === objectAttributeHash,
+        )
+      ) {
+        const inlines: InlineTypeNode[] = []
+        for (const obj of field.of) {
+          // eslint-disable-next-line
+          if (obj.type !== 'object' || obj.rest === undefined || obj.rest.type !== 'inline') {
+            continue
+          }
+          inlines.push(obj.rest)
+        }
+
+        const rest = optimizeUnions({
+          type: 'union',
+          of: inlines,
+        }) as UnionTypeNode<InlineTypeNode> | InlineTypeNode // todo: fix me
+
+        return {
+          type: 'object',
+          attributes: field.of[0].attributes,
+          rest,
+        } satisfies ObjectTypeNode
+      }
+    }
+
     // flatten union
     for (let idx = 0; field.of.length > idx; idx++) {
       const subField = field.of[idx]

src/typeEvaluator/typeHelpers.ts

@@ -68,13 +68,53 @@ export function nullUnion(node: TypeNode): UnionTypeNode {
   return unionOf(node, {type: 'null'})
 }
 
+export function arrayOf(node: TypeNode): ArrayTypeNode {
+  return {
+    type: 'array',
+    of: node,
+  } satisfies ArrayTypeNode
+}
+
 export function unionOf(...nodes: TypeNode[]): UnionTypeNode {
   return {
     type: 'union',
     of: nodes,
   } satisfies UnionTypeNode
 }
 
+export function objectWith(...attributes: [string, ObjectAttribute][]): ObjectTypeNode {
+  return {
+    type: 'object',
+    attributes: Object.fromEntries(attributes),
+  } satisfies ObjectTypeNode
+}
+
+export function objectWithRest(
+  rest: ObjectTypeNode['rest'],
+  ...attributes: [string, ObjectAttribute][]
+): ObjectTypeNode {
+  return {
+    type: 'object',
+    attributes: Object.fromEntries(attributes),
+    rest,
+  } satisfies ObjectTypeNode
+}
+
+export function objectAttribute(
+  key: string,
+  value: TypeNode,
+  optional?: boolean,
+): [string, ObjectAttribute] {
+  return [
+    key,
+    {
+      type: 'objectAttribute',
+      value,
+      optional,
+    } satisfies ObjectAttribute,
+  ]
+}
+
 type ConcreteTypeNode =
   | BooleanTypeNode
   | NullTypeNode

src/typeEvaluator/types.ts

@@ -75,7 +75,7 @@ export interface ObjectTypeNode<T extends TypeNode = TypeNode> {
   /** a collection of attributes */
   attributes: Record<string, ObjectAttribute<T>>
   /** an optional rest value */
-  rest?: ObjectTypeNode | UnknownTypeNode | InlineTypeNode
+  rest?: ObjectTypeNode | UnknownTypeNode | InlineTypeNode | UnionTypeNode<InlineTypeNode>
   /* an optional reference to the document this object dereferences to */
   dereferencesTo?: string
 }