@travetto/transformer 5.0.0-rc.5 → 5.0.0-rc.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "5.0.0-rc.5",
+  "version": "5.0.0-rc.7",
   "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.4",
+    "@travetto/manifest": "^5.0.0-rc.5",
     "tslib": "^2.6.3",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.4"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/resolver/builder.ts

@@ -7,7 +7,7 @@ import { DocUtil } from '../util/doc';
 import { CoreUtil } from '../util/core';
 import { DeclarationUtil } from '../util/declaration';
 import { LiteralUtil } from '../util/literal';
-import { TemplateLiteralPart } from '../types/shared';
+import { transformCast, TemplateLiteralPart } from '../types/shared';
 
 import { Type, AnyType, UnionType, TransformResolver, TemplateType } from './types';
 import { CoerceUtil } from './coerce';
@@ -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 })
@@ -165,8 +166,7 @@ export const TypeBuilder: {
 
       if (name in GLOBAL_SIMPLE) {
         const cons = GLOBAL_SIMPLE[name];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const ret = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, cons as typeof String, false) :
+        const ret = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, transformCast(cons), false) :
           undefined;
 
         return {
@@ -183,6 +183,12 @@ export const TypeBuilder: {
           ctor: cons,
           tsTypeArguments: resolver.getAllTypeArguments(type)
         };
+      } else {
+        return {
+          key: 'literal',
+          name: 'Object',
+          ctor: Object
+        };
       }
     }
   },
@@ -225,8 +231,7 @@ export const TypeBuilder: {
           ctor: String,
           nullable: type.nullable,
           undefinable: type.undefinable,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          template: { op: 'or', values: subTypes.map(x => (x as TemplateType).template!) }
+          template: { op: 'or', values: subTypes.map(x => transformCast<TemplateType>(x).template!) }
         };
       } else if (subTypes.length === 1) {
         return { undefinable, nullable, ...first };
@@ -244,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;
@@ -50,8 +51,7 @@ export class CoerceUtil {
     switch (type) {
       case Date: {
         const res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          new Date(parseInt(input as string, 10)) : new Date(input as Date);
+          new Date(parseInt(`${input}`, 10)) : new Date(`${input}`);
         if (strict && Number.isNaN(res.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
@@ -64,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/resolver/service.ts

@@ -7,6 +7,7 @@ import { TypeCategorize, TypeBuilder } from './builder';
 import { VisitCache } from './cache';
 import { DocUtil } from '../util/doc';
 import { DeclarationUtil } from '../util/declaration';
+import { transformCast } from '../types/shared';
 
 /**
  * Implementation of TransformResolver
@@ -80,8 +81,7 @@ export class SimpleResolver implements TransformResolver {
    * Fetch all type arguments for a give type
    */
   getAllTypeArguments(ref: ts.Type): ts.Type[] {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return this.#tsChecker.getTypeArguments(ref as ts.TypeReference) as ts.Type[];
+    return transformCast(this.#tsChecker.getTypeArguments(transformCast(ref)));
   }
 
   /**
@@ -148,8 +148,7 @@ export class SimpleResolver implements TransformResolver {
           delete result.tsSubTypes;
         }
         if (finalize) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          result = finalize(result as never);
+          result = finalize(transformCast(result));
         }
       }
 

package/src/state.ts

@@ -15,14 +15,12 @@ import { CoreUtil } from './util/core';
 import { LiteralUtil } from './util/literal';
 import { SystemUtil } from './util/system';
 
-function hasOriginal(n: unknown): n is { original: ts.Node } {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!n && !(n as { parent?: unknown }).parent && !!(n as { original: unknown }).original;
+function hasOriginal(n: ts.Node): n is ts.Node & { original: ts.Node } {
+  return !!n && !n.parent && 'original' in n && !!n.original;
 }
 
-function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!n && !!(n as { name?: { escapedText?: string } }).name?.escapedText;
+function hasEscapedName(n: ts.Node): n is ts.Node & { name: { escapedText: string } } {
+  return !!n && 'name' in n && typeof n.name === 'object' && !!n.name && 'escapedText' in n.name && !!n.name.escapedText;
 }
 
 /**
@@ -151,8 +149,7 @@ export class TransformerState implements State {
     const targets = DocUtil.readAugments(this.#resolver.getType(ident));
     const module = file ? mod : undefined;
     const name = ident ?
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      ident.escapedText! as string :
+      ident.escapedText?.toString()! :
       undefined;
 
     if (ident && name) {
@@ -193,10 +190,11 @@ export class TransformerState implements State {
       while (n && !ts.isSourceFile(n.parent) && n !== n.parent) {
         n = n.parent;
       }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const nStmt: ts.Statement = n as ts.Statement;
-      if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
-        idx = stmts.indexOf(nStmt) - 1;
+      if (!ts.isStatement(n)) {
+        throw new Error('Unable to find statement at top level');
+      }
+      if (n && ts.isSourceFile(n.parent) && stmts.indexOf(n) >= 0) {
+        idx = stmts.indexOf(n) - 1;
       }
     } else if (before !== undefined) {
       idx = before;
@@ -225,8 +223,7 @@ export class TransformerState implements State {
   fromLiteral(val: unknown[]): ts.ArrayLiteralExpression;
   fromLiteral(val: string | boolean | number): ts.LiteralExpression;
   fromLiteral(val: unknown): ts.Node {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return LiteralUtil.fromLiteral(this.factory, val as object);
+    return LiteralUtil.fromLiteral(this.factory, val!);
   }
 
   /**
@@ -308,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());
             }

package/src/types/shared.ts

@@ -30,3 +30,8 @@ export type Import = {
 /** Template Literal Types */
 export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
 export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+
+export function transformCast<T>(input: unknown): T {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return input as T;
+}

package/src/types/visitor.ts

@@ -42,6 +42,6 @@ export interface NodeTransformer<S extends State = State, T extends TransformerT
   type: T;
   key: string;
   target?: string[];
-  before?(state: S, node: N, dm?: DecoratorMeta): ts.Node | undefined;
-  after?(state: S, node: N, dm?: DecoratorMeta): ts.Node | undefined;
+  before?<Z extends ts.Node = ts.Node>(state: S, node: N, dm?: DecoratorMeta): Z | undefined;
+  after?<Z extends ts.Node = ts.Node>(state: S, node: N, dm?: DecoratorMeta): Z | undefined;
 }

package/src/util/core.ts

@@ -9,16 +9,14 @@ export class CoreUtil {
    * See if inbound node has an original property
    */
   static hasOriginal(o: ts.Node): o is (ts.Node & { original: ts.Node }) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return 'original' in o && !!(o as { original?: ts.Node }).original;
+    return 'original' in o && !!o.original;
   }
 
   /**
    * See if type has target
    */
   static hasTarget(o: ts.Type): o is (ts.Type & { target: ts.Type }) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return 'target' in o && !!(o as { target?: ts.Type }).target;
+    return 'target' in o && !!o.target;
   }
 
   /**
@@ -36,12 +34,19 @@ export class CoreUtil {
   /**
    * Find the primary argument of a call expression, or decorator.
    */
-  static getArgument<T extends ts.Expression = ts.Expression>(node: ts.CallExpression | undefined, position = 0): T | undefined {
-    if (node && node!.arguments && node!.arguments.length >= position + 1) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return node.arguments[position] as T;
+  static findArgument<T extends ts.Expression = ts.Expression>(node: ts.CallExpression | undefined, pred: (x: ts.Expression) => x is T): T | undefined {
+    if (node && node.arguments && node.arguments.length) {
+      return node.arguments.find(pred);
+    }
+  }
+
+  /**
+   * Find the first argument of a call expression, or decorator.
+   */
+  static firstArgument(node: ts.CallExpression | undefined): ts.Expression | undefined {
+    if (node && node!.arguments && node!.arguments.length) {
+      return node.arguments[0];
     }
-    return;
   }
 
   /**

package/src/util/declaration.ts

@@ -57,8 +57,9 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, no-bitwise
-    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
+    const _ts: typeof ts & { getObjectFlags?(t: ts.Type): ts.ObjectFlags } = ts;
+    // eslint-disable-next-line no-bitwise
+    return _ts.getObjectFlags!(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
   }
 
   /**

package/src/util/decorator.ts

@@ -56,15 +56,14 @@ export class DecoratorUtil {
   /**
    * Find the primary argument of a call expression, or decorator.
    */
-  static getPrimaryArgument<T extends ts.Expression = ts.Expression>(node: ts.Decorator | undefined): T | undefined {
-    return CoreUtil.getArgument(node && ts.isCallExpression(node.expression) ? node.expression : undefined);
+  static getPrimaryArgument(node: ts.Decorator | undefined): ts.Expression | undefined {
+    return CoreUtil.firstArgument(node && ts.isCallExpression(node.expression) ? node.expression : undefined);
   }
 
   /**
    * Find the primary argument of a call expression, or decorator.
    */
-  static getArguments<T extends ts.Expression = ts.Expression>(node: ts.Decorator | undefined): T[] | undefined {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return node && ts.isCallExpression(node.expression) ? [...node.expression.arguments] as T[] : undefined;
+  static getArguments(node: ts.Decorator | undefined): ts.Expression[] | undefined {
+    return node && ts.isCallExpression(node.expression) ? [...node.expression.arguments] : undefined;
   }
 }

package/src/util/doc.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { DeclDocumentation } from '../types/shared';
+import { transformCast, DeclDocumentation } from '../types/shared';
 import { CoreUtil } from './core';
 import { DeclarationUtil } from './declaration';
 
@@ -38,8 +38,7 @@ export class DocUtil {
     if (node) {
       const tags = ts.getJSDocTags(node);
       while (!this.hasJSDoc(node) && CoreUtil.hasOriginal(node)) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        node = node.original as ts.Declaration;
+        node = transformCast<ts.Declaration>(node.original);
       }
 
       const docs = this.hasJSDoc(node) ? node.jsDoc : undefined;

package/src/util/literal.ts

@@ -1,6 +1,20 @@
 import ts from 'typescript';
 
-import { TemplateLiteral } from '../types/shared';
+import { transformCast, TemplateLiteral } from '../types/shared';
+
+const TypedObject: {
+  keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
+} & ObjectConstructor = Object;
+
+function isNode(n: unknown): n is ts.Node {
+  return !!n && typeof n === 'object' && 'kind' in n;
+}
+
+const KNOWN_FNS = new Set<unknown>([String, Number, Boolean, Date, RegExp]);
+
+function isKnownFn(n: unknown): n is Function {
+  return KNOWN_FNS.has(n);
+}
 
 /**
  * Utilities for dealing with literals
@@ -27,10 +41,8 @@ export class LiteralUtil {
   static fromLiteral(factory: ts.NodeFactory, val: unknown[]): ts.ArrayLiteralExpression;
   static fromLiteral(factory: ts.NodeFactory, val: string | boolean | number): ts.LiteralExpression;
   static fromLiteral(factory: ts.NodeFactory, val: unknown): ts.Node {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    if (val && (val as ts.Expression).kind) { // If already a node
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return val as ts.Node;
+    if (isNode(val)) { // If already a node
+      return val;
     } else if (Array.isArray(val)) {
       val = factory.createArrayLiteralExpression(val.map(v => this.fromLiteral(factory, v)));
     } else if (val === undefined) {
@@ -45,15 +57,12 @@ export class LiteralUtil {
       val = val ? factory.createTrue() : factory.createFalse();
     } else if (val instanceof RegExp) {
       val = factory.createRegularExpressionLiteral(`/${val.source}/${val.flags ?? ''}`);
-    } else if (val === String || val === Number || val === Boolean || val === Date || val === RegExp) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      val = factory.createIdentifier((val as Function).name);
+    } else if (isKnownFn(val)) {
+      val = factory.createIdentifier(val.name);
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const ov = val as object;
+      const ov = val;
       const pairs: ts.PropertyAssignment[] = [];
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      for (const k of Object.keys(ov) as (keyof typeof ov)[]) {
+      for (const k of TypedObject.keys(ov)) {
         if (ov[k] !== undefined) {
           pairs.push(
             factory.createPropertyAssignment(k, this.fromLiteral(factory, ov[k]))
@@ -62,8 +71,7 @@ export class LiteralUtil {
       }
       return factory.createObjectLiteralExpression(pairs);
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return val as ts.Expression;
+    return transformCast(val);
   }
 
   /**
@@ -164,8 +172,7 @@ export class LiteralUtil {
       } else if (typeof el === 'string' || typeof el === 'number' || typeof el === 'boolean') {
         out.push(`${el}`);
       } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        out.push(`(?:${this.templateLiteralToRegex(el as TemplateLiteral, false)})`);
+        out.push(`(?:${this.templateLiteralToRegex(transformCast(el), false)})`);
       }
     }
     const body = out.join(template.op === 'and' ? '' : '|');

package/src/util/log.ts

@@ -5,6 +5,8 @@ const exclude = new Set([
   'nextContainer', 'modifierFlagsCache', 'declaredProperties'
 ]);
 
+const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(o: T): K[] } & ObjectConstructor = Object;
+
 /**
  * Utilities for logging typescript nodes
  */
@@ -33,11 +35,9 @@ export class LogUtil {
     if (Array.isArray(x)) {
       return x.map(v => this.collapseNode(v, cache));
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const ox = x as object;
+      const ox = x;
       const out: Record<string, unknown> = {};
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      for (const key of Object.keys(ox) as (keyof typeof ox)[]) {
+      for (const key of TypedObject.keys(ox)) {
         if (Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key) || ox[key] === undefined) {
           continue;
         }

package/src/visitor.ts

@@ -126,8 +126,7 @@ export class VisitorFactory<S extends State = State> {
     }
 
     for (const all of set[phase]!.get('ALL') ?? []) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      node = (all[phase]!(state, node) as T) ?? node;
+      node = all[phase]!<T>(state, node) ?? node;
     }
     return node;
   }
@@ -160,8 +159,7 @@ export class VisitorFactory<S extends State = State> {
 
       // For all matching handlers, execute
       for (const item of values) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        node = (item[phase]!(state, node, dec) as T) ?? node;
+        node = item[phase]!<T>(state, node, dec) ?? node;
       }
     }
     return node;