@travetto/transformer 5.0.0-rc.4 → 5.0.0-rc.6

package/README.md

@@ -105,7 +105,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEST = void 0;
 const tslib_1 = require("tslib");
 const Ⲑ_function_1 = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
-var ᚕm = ["@travetto/transformer", "doc/upper"];
+var ᚕm = ["@travetto/transformer", "doc/upper.ts"];
 class TEST {
     static Ⲑinit = Ⲑ_function_1.registerFunction(TEST, ᚕm, { hash: 649563175, lines: [1, 9] }, { COMPUTEAGE: { hash: 1286718349, lines: [6, 8, 7] } }, false, false);
     NAME;

package/package.json

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

package/src/importer.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { PackageUtil, path } from '@travetto/manifest';
+import { ManifestModuleUtil, PackageUtil, path } from '@travetto/manifest';
 
 import { AnyType, TransformResolver, ManagedType } from './resolver/types';
 import { ImportUtil } from './util/import';
@@ -104,6 +104,10 @@ export class ImportManager {
   importFile(file: string, name?: string): Import {
     file = this.#resolver.getFileImportName(file);
 
+    if (file.endsWith('.ts') && !file.endsWith('.d.ts')) {
+      file = ManifestModuleUtil.withOutputExtension(file);
+    }
+
     // Allow for node classes to be imported directly
     if (/@types\/node/.test(file)) {
       file = PackageUtil.resolveImport(file.replace(/.*@types\/node\//, '').replace(D_OR_D_TS_EXT_RE, ''));

package/src/manager.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { ManifestIndex } from '@travetto/manifest';
+import { ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
 
 import { NodeTransformer } from './types/visitor';
 import { VisitorFactory } from './visitor';
@@ -25,7 +25,7 @@ export class TransformerManager {
 
     for (const file of transformerFiles) { // Exclude based on blacklist
       const entry = manifestIndex.getEntry(file)!;
-      transformers.push(...getAllTransformers(await import(entry.import), entry.module));
+      transformers.push(...getAllTransformers(await import(ManifestModuleUtil.withOutputExtension(entry.import)), entry.module));
     }
 
     for (const x of transformers) {

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';
@@ -165,8 +165,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 {
@@ -225,8 +224,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 };

package/src/resolver/coerce.ts

@@ -50,8 +50,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}`);
         }

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
@@ -41,14 +42,15 @@ export class SimpleResolver implements TransformResolver {
     }
 
     return this.#manifestIndex.getEntry(ManifestModuleUtil.getFileType(sourceFile) === 'ts' ? sourceFile : `${sourceFile}.js`) ??
-      this.#manifestIndex.getFromImport(ManifestModuleUtil.sourceToBlankExt(sourceFile).replace(/^.*node_modules\//, ''));
+      this.#manifestIndex.getFromImport(ManifestModuleUtil.withoutSourceExtension(sourceFile).replace(/^.*node_modules\//, ''));
   }
+
   /**
    * Resolve an import name (e.g. @module/path/file) for a file
    */
   getFileImportName(file: string, removeExt?: boolean): string {
     const imp = this.getFileImport(file)?.import ?? file;
-    return removeExt ? ManifestModuleUtil.sourceToBlankExt(imp) : imp;
+    return removeExt ? ManifestModuleUtil.withoutSourceExtension(imp) : imp;
   }
 
   /**
@@ -79,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)));
   }
 
   /**
@@ -147,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

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { path, ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
+import { path, ManifestIndex } from '@travetto/manifest';
 
 import { ManagedType, AnyType, ForeignType } from './resolver/types';
 import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
@@ -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!);
   }
 
   /**
@@ -266,7 +263,7 @@ export class TransformerState implements State {
       this.#modIdent = this.createIdentifier('ᚕm');
       const entry = this.#resolver.getFileImport(this.source.fileName);
       const decl = this.factory.createVariableDeclaration(this.#modIdent, undefined, undefined,
-        this.fromLiteral([entry?.module, ManifestModuleUtil.sourceToBlankExt(entry?.relativeFile ?? '')])
+        this.fromLiteral([entry?.module, entry?.relativeFile ?? ''])
       );
       this.addStatements([
         this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))

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;