@travetto/transformer 8.0.0 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "ast-transformations",
@@ -28,9 +28,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@travetto/manifest": "^8.0.0",
+    "@travetto/manifest": "^8.0.1",
     "tslib": "^2.8.1",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/resolver/builder.ts

@@ -33,6 +33,24 @@ const getMappedFields = (type: ts.Type): string[] | undefined => {
   }
 };
 
+const hasComplexSubType = (type: ts.UnionOrIntersectionType): boolean => {
+  if (type.types.filter(x => (x.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) === 0).length === 1) {
+    return false;
+  }
+
+  for (const sub of type.types) {
+    if (
+      sub.isClassOrInterface() ||
+      (sub.isUnionOrIntersection() && hasComplexSubType(sub)) ||
+      sub.getFlags() & ts.TypeFlags.Object ||
+      sub.getFlags() & ts.TypeFlags.NonPrimitive
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
 /**
  * List of global types that can be parameterized
  */
@@ -87,7 +105,11 @@ type Category = Exclude<AnyType['key'], 'pointer'> | 'concrete';
 /**
  * Type categorizer, input for builder
  */
-export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { category: Category; type: ts.Type } {
+export function TypeCategorize(
+  resolver: TransformResolver,
+  type: ts.Type,
+  context: { importName: string }
+): { category: Category; type: ts.Type } {
   const flags = type.getFlags();
   const objectFlags = DeclarationUtil.getObjectFlags(type) ?? 0;
 
@@ -113,6 +135,9 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     // Tuple type?
     return { category: 'tuple', type };
   } else if (type.isUnionOrIntersection()) {
+    if (hasComplexSubType(type)) {
+      return { category: 'shape', type };
+    }
     return { category: 'composition', type };
   } else if (objectFlags & ts.ObjectFlags.Anonymous) {
     try {

package/src/resolver/service.ts

@@ -88,7 +88,7 @@ export class SimpleResolver implements TransformResolver {
   getAllTypeArguments(ref: ts.Type): [templateName: string, type: ts.Type][] {
     const types = this.#tsChecker.getTypeArguments(transformCast(ref));
     let names: string[] | undefined;
-    if (ref.symbol.declarations?.[0]) {
+    if (ref.symbol?.declarations?.[0]) {
       const first = ref.symbol.declarations[0];
       if (ts.isClassLike(first) || ts.isInterfaceDeclaration(first) || ts.isTypeAliasDeclaration(first)) {
         names = first.typeParameters?.map(tp => tp.name.getText()) ?? [];
@@ -135,7 +135,7 @@ export class SimpleResolver implements TransformResolver {
         throw new Error(`Object structure too nested: ${'getText' in node ? node.getText() : ''}`);
       }
 
-      const { category, type } = TypeCategorize(this, resType);
+      const { category, type } = TypeCategorize(this, resType, { importName });
       // TODO: Figure out how to get this legitimately
       const typeArguments: ts.Type[] =
         'resolvedTypeArguments' in resType && resType.resolvedTypeArguments ? transformCast(resType.resolvedTypeArguments) : [];