@travetto/transformer 5.0.0-rc.6 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "5.0.0-rc.6",
+  "version": "5.0.0",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -24,9 +24,9 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^5.0.0-rc.5",
+    "@travetto/manifest": "^5.0.0",
     "tslib": "^2.6.3",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.4"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/resolver/builder.ts

@@ -54,7 +54,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     return { category: 'undefined', type };
   } else if (DocUtil.readDocTag(type, 'concrete').length) {
     return { category: 'concrete', type };
-  } else if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) { // Any or unknown
+  } else if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) { // Any or unknown
     return { category: 'unknown', type };
   } else if (objectFlags & ts.ObjectFlags.Reference && !CoreUtil.getSymbol(type)) { // Tuple type?
     return { category: 'tuple', type };
@@ -91,9 +91,10 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
   } else if (flags & (ts.TypeFlags.TemplateLiteral)) {
     return { category: 'template', type };
   } else if (flags & (
-    ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral |
-    ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral |
-    ts.TypeFlags.String | ts.TypeFlags.StringLiteral |
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.NumberLike |
+    ts.TypeFlags.StringLike |
     ts.TypeFlags.Void | ts.TypeFlags.Undefined
   )) {
     return { category: 'literal', type };
@@ -104,7 +105,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
   } else if (type.isLiteral()) {
     return { category: 'shape', type };
   }
-  return { category: 'unknown', type };
+  return { category: 'literal', type };
 }
 
 /**
@@ -117,7 +118,7 @@ export const TypeBuilder: {
   }
 } = {
   unknown: {
-    build: (resolver, type) => undefined
+    build: (resolver, type) => ({ key: 'unknown' })
   },
   undefined: {
     build: (resolver, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
@@ -182,6 +183,12 @@ export const TypeBuilder: {
           ctor: cons,
           tsTypeArguments: resolver.getAllTypeArguments(type)
         };
+      } else {
+        return {
+          key: 'literal',
+          name: 'Object',
+          ctor: Object
+        };
       }
     }
   },
@@ -242,7 +249,7 @@ export const TypeBuilder: {
       const tsTypeArguments = resolver.getAllTypeArguments(type);
       const props = resolver.getPropertiesOfType(type);
       if (props.length === 0) {
-        return { key: 'unknown', name, importName };
+        return { key: 'literal', name: 'Object', ctor: Object };
       }
 
       for (const member of props) {

package/src/resolver/coerce.ts

@@ -33,6 +33,7 @@ export class CoerceUtil {
    * @param strict Should a failure to coerce throw an error?
    */
   static coerce(input: unknown, type: typeof String, strict?: boolean): string;
+  static coerce(input: unknown, type: typeof BigInt, strict?: boolean): bigint;
   static coerce(input: unknown, type: typeof Number, strict?: boolean): number;
   static coerce(input: unknown, type: typeof Boolean, strict?: boolean): boolean;
   static coerce(input: unknown, type: typeof Date, strict?: boolean): Date;
@@ -63,6 +64,16 @@ export class CoerceUtil {
         }
         return res;
       }
+      case BigInt: {
+        try {
+          return BigInt(typeof input === 'string' || typeof input === 'number' ? input : `${input}`);
+        } catch {
+          if (strict) {
+            throw new Error(`Invalid numeric value: ${input}`);
+          }
+          return;
+        }
+      }
       case Boolean: {
         const match = `${input}`.match(/^((?<TRUE>true|yes|1|on)|false|no|off|0)$/i);
         if (strict && !match) {

package/src/state.ts

@@ -305,9 +305,9 @@ export class TransformerState implements State {
       const fileName = tgt.getSourceFile().fileName;
 
       if (fileName === this.source.fileName) { // if in same file suffix with location
-        let child = node;
+        let child: ts.Node = tgt;
         while (child && !ts.isSourceFile(child)) {
-          if (ts.isFunctionDeclaration(child) || ts.isMethodDeclaration(child) || ts.isClassDeclaration(child)) {
+          if (ts.isFunctionDeclaration(child) || ts.isMethodDeclaration(child) || ts.isClassDeclaration(child) || ts.isInterfaceDeclaration(child)) {
             if (child.name) {
               unique.push(child.name.getText());
             }