@travetto/transformer 7.1.2 → 8.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "7.1.2",
+  "version": "8.0.0-alpha.0",
   "type": "module",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
@@ -25,9 +25,9 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.1.2",
+    "@travetto/manifest": "^8.0.0-alpha.0",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.0"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/importer.ts

@@ -110,16 +110,15 @@ export class ImportManager {
    * Produces a unique identifier for a given file
    */
   getIdentifier(file: string, name?: string): ts.Identifier {
-    if (!this.#identifiers.has(file)) {
+    return this.#identifiers.getOrInsertComputed(file, () => {
       if (name) {
-        this.#identifiers.set(file, this.factory.createIdentifier(name));
+        return this.factory.createIdentifier(name);
       } else {
         const key = path.basename(file, path.extname(file)).replace(/\W+/g, '_');
         const suffix = this.#idx[key] = (this.#idx[key] ?? -1) + 1;
-        this.#identifiers.set(file, this.factory.createIdentifier(`Δ${key}${suffix ? suffix : ''}`));
+        return this.factory.createIdentifier(`Δ${key}${suffix ? suffix : ''}`);
       }
-    }
-    return this.#identifiers.get(file)!;
+    });
   }
 
   /**

package/src/resolver/builder.ts

@@ -43,7 +43,12 @@ const GLOBAL_COMPLEX: Record<string, Function> = {
 const UNDEFINED_GLOBAL = { undefined: 1, void: 1, null: 1 };
 const SIMPLE_NAMES: Record<string, string> = { String: 'string', Number: 'number', Boolean: 'boolean', Object: 'object' };
 const GLOBAL_SIMPLE: Record<string, Function> = {
-  RegExp, Date, Number, Boolean, String, Function, Object, Error,
+  RegExp, Date, Number, Boolean, String, Function, Object, Error, BigInt,
+  ArrayBuffer, SharedArrayBuffer,
+  Uint8Array, Uint16Array, Uint32Array,
+  Int8Array, Int16Array, Int32Array,
+  Uint8ClampedArray, BigInt64Array, BigUint64Array,
+  Float16Array, Float32Array, Float64Array,
   PromiseConstructor: Promise.constructor
 };
 
@@ -177,7 +182,7 @@ export const TypeBuilder: {
   literal: {
     build: (resolver, type) => {
       // Handle void/undefined
-      const name = resolver.getTypeAsString(type) ?? '';
+      const name = (resolver.getTypeAsString(type) ?? '').split('<')[0]; // Ensure we strip off any type arguments for lookup
       const complexName = CoreUtil.getSymbol(type)?.getName() ?? '';
 
       if (name in UNDEFINED_GLOBAL) {
@@ -366,4 +371,4 @@ export const TypeBuilder: {
       return { key: 'managed', name, importName };
     }
   }
-};
+};

package/src/state.ts

@@ -144,21 +144,20 @@ export class TransformerState implements State {
   /**
    * Import a decorator, generally to handle erasure
    */
-  importDecorator(pth: string, name: string): ts.PropertyAccessExpression | undefined {
-    if (!this.#decorators.has(`${pth}:${name}`)) {
-      const ref = this.#imports.importFile(pth);
+  importDecorator(location: string, name: string): ts.PropertyAccessExpression | undefined {
+    return this.#decorators.getOrInsertComputed(`${location}:${name}`, () => {
+      const ref = this.#imports.importFile(location);
       const identifier = this.factory.createIdentifier(name);
-      this.#decorators.set(name, this.factory.createPropertyAccessExpression(ref.identifier, identifier));
-    }
-    return this.#decorators.get(name);
+      return this.factory.createPropertyAccessExpression(ref.identifier, identifier);
+    });
   }
 
   /**
    * Create a decorator to add functionality to a declaration
    */
-  createDecorator(pth: string, name: string, ...contents: (ts.Expression | undefined)[]): ts.Decorator {
-    this.importDecorator(pth, name);
-    return CoreUtil.createDecorator(this.factory, this.#decorators.get(name)!, ...contents);
+  createDecorator(location: string, name: string, ...contents: (ts.Expression | undefined)[]): ts.Decorator {
+    this.importDecorator(location, name);
+    return CoreUtil.createDecorator(this.factory, this.#decorators.get(`${location}:${name}`)!, ...contents);
   }
 
   /**
@@ -189,7 +188,7 @@ export class TransformerState implements State {
   getDecoratorList(node: ts.Node): DecoratorMeta[] {
     return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? [])
       .map(decorator => this.getDecoratorMeta(decorator))
-      .filter(meta => !!meta) : [];
+      .filter(metadata => !!metadata) : [];
   }
 
   /**
@@ -225,10 +224,7 @@ export class TransformerState implements State {
     } else if (before !== undefined) {
       idx = before;
     }
-    if (!this.added.has(idx)) {
-      this.added.set(idx, []);
-    }
-    this.added.get(idx)!.push(...added);
+    this.added.getOrInsert(idx, []).push(...added);
   }
 
   /**
@@ -280,15 +276,30 @@ export class TransformerState implements State {
     return this.factory.createIdentifier(typeof name === 'string' ? name : name.getText());
   }
 
+  /**
+   * Gets the module identifier target
+   */
+  getModuleIdentifierTarget(): [string | undefined, string] {
+    const entry = this.#resolver.getFileImport(this.source.fileName);
+    return [entry?.module, entry?.relativeFile ?? ''];
+  }
+
+  /**
+   * Build a class identifier string
+   */
+  buildClassId(text: string): string {
+    const [module, source] = this.getModuleIdentifierTarget();
+    return `${module}:${source}#${text}`;
+  }
+
   /**
    * Get filename identifier, regardless of module system
    */
   getModuleIdentifier(): ts.Expression {
     if (this.#moduleIdentifier === undefined) {
       this.#moduleIdentifier = this.factory.createUniqueName('Δm');
-      const entry = this.#resolver.getFileImport(this.source.fileName);
       const declaration = this.factory.createVariableDeclaration(this.#moduleIdentifier, undefined, undefined,
-        this.fromLiteral([entry?.module, entry?.relativeFile ?? ''])
+        this.fromLiteral(this.getModuleIdentifierTarget())
       );
       this.addStatements([
         this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([declaration], ts.NodeFlags.Const))
@@ -309,7 +320,7 @@ export class TransformerState implements State {
     const targetScope = typeof input === 'string' ? input : input[ModuleNameSymbol]!;
     const target = `${targetScope}:${name}`;
     const list = this.getDecoratorList(node);
-    return list.find(meta => meta.targets?.includes(target) && (!module || meta.name === name && meta.module === module))?.decorator;
+    return list.find(item => item.targets?.includes(target) && (!module || item.name === name && item.module === module))?.decorator;
   }
 
   /**
@@ -364,11 +375,11 @@ export class TransformerState implements State {
    */
   registerIdentifier(id: string): [identifier: ts.Identifier, exists: boolean] {
     let exists = true;
-    if (!this.#syntheticIdentifiers.has(id)) {
-      this.#syntheticIdentifiers.set(id, this.factory.createIdentifier(id));
+    const resolved = this.#syntheticIdentifiers.getOrInsertComputed(id, () => {
       exists = false;
-    }
-    return [this.#syntheticIdentifiers.get(id)!, exists];
+      return this.factory.createIdentifier(id);
+    });
+    return [resolved, exists];
   }
 
   /**
@@ -403,30 +414,40 @@ export class TransformerState implements State {
   /**
    * Produce a foreign target type
    */
-  getForeignTarget(type: ForeignType): ts.Expression {
+  getForeignTarget(typeOrClassId: ForeignType | string): ts.Expression {
     const file = this.importFile(FOREIGN_TYPE_REGISTRY_FILE);
     return this.factory.createCallExpression(this.createAccess(
       file.identifier,
       this.factory.createIdentifier('foreignType'),
     ), [], [
-      this.fromLiteral(type.classId)
+      this.fromLiteral(typeof typeOrClassId === 'string' ? typeOrClassId : typeOrClassId.classId)
     ]);
   }
 
   /**
    * Return a concrete type the given type of a node
    */
-  getConcreteType(node: ts.Node): ts.Expression {
+  getConcreteType(node: ts.Node, fallback?: ts.Expression): ts.Expression {
     const type = this.resolveType(node);
-
-    if (type.key === 'managed') {
-      return this.getOrImport(type);
-    } else if (type.key === 'foreign') {
-      return this.getForeignTarget(type);
-    } else {
-      const file = node.getSourceFile().fileName;
-      const source = this.getFileImportName(file);
-      throw new Error(`Unable to import non-external type: ${node.getText()} ${type.key}: ${source}`);
+    try {
+      if (type.key === 'managed') {
+        return this.getOrImport(type);
+      } else if (type.key === 'foreign') {
+        return this.getForeignTarget(type);
+      } else {
+        const targetId = this.buildClassId(node.getText());
+        if (this.#resolver.isKnownFile(node.getSourceFile().fileName)) {
+          return this.getForeignTarget(targetId);
+        } else {
+          throw new Error(`Unable to import non - external type: ${node.getText()} ${type.key}: ${targetId} `);
+        }
+      }
+    } catch (err) {
+      if (fallback) {
+        return fallback;
+      } else {
+        throw err;
+      }
     }
   }
 

package/src/types/shared.ts

@@ -27,7 +27,7 @@ export type Import = {
 };
 
 /** Template Literal Types */
-export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
+export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor | BigIntConstructor;
 export type TemplateLiteral = { operation: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
 
 export function transformCast<T>(input: unknown): T {

package/src/types/visitor.ts

@@ -35,10 +35,7 @@ export type Transformer = {
   name: string;
 };
 
-export type TransformerSet<S extends State = State> = {
-  before?: Map<string, NodeTransformer<S>[]>;
-  after?: Map<string, NodeTransformer<S>[]>;
-};
+export type TransformerSet<S extends State = State> = Map<'before' | 'after', Map<string, NodeTransformer<S>[]>>;
 
 export interface NodeTransformer<S extends State = State, T extends TransformerType = TransformerType, N extends ts.Node = ts.Node> {
   type: T;

package/src/util/declaration.ts

@@ -33,7 +33,7 @@ export class DeclarationUtil {
    * Find declaration for a type, symbol or a declaration
    */
   static getDeclarations(type: ts.Type | ts.Symbol | ts.Declaration[]): ts.Declaration[] {
-    let declarations: ts.Declaration[] = [];
+    let declarations: ts.Declaration[];
     if (Array.isArray(type)) {
       declarations = type;
     } else {

package/src/util/literal.ts

@@ -56,6 +56,8 @@ export class LiteralUtil {
     } else if (typeof value === 'number') {
       const number = factory.createNumericLiteral(Math.abs(value));
       value = value < 0 ? factory.createPrefixMinus(number) : number;
+    } else if (typeof value === 'bigint') {
+      value = factory.createBigIntLiteral(value.toString());
     } else if (typeof value === 'boolean') {
       value = value ? factory.createTrue() : factory.createFalse();
     } else if (value instanceof RegExp) {
@@ -103,6 +105,8 @@ export class LiteralUtil {
       return null;
     } else if (ts.isStringLiteral(value)) {
       return value.text;
+    } else if (ts.isBigIntLiteral(value)) {
+      return BigInt(value.text.replace(/n$/i, ''));
     } else if (ts.isNumericLiteral(value)) {
       const txt = value.text;
       if (txt.includes('.')) {
@@ -179,6 +183,8 @@ export class LiteralUtil {
         out.push('(?:true|false)');
       } else if (value === String) {
         out.push('.+');
+      } else if (typeof value === 'bigint') {
+        out.push(`${value}n`);
       } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         out.push(`${value}`);
       } else {

package/src/visitor.ts

@@ -60,22 +60,14 @@ export class VisitorFactory<S extends State = State> {
    */
   #init(transformers: NodeTransformer<S, TransformerType, ts.Node>[]): void {
     for (const trn of transformers) {
-      if (!this.#transformers.has(trn.type)) {
-        this.#transformers.set(trn.type, {});
-      }
-      const set = this.#transformers.get(trn.type)!;
+      const set = this.#transformers.getOrInsert(trn.type, new Map());
+
       const targets = trn.target && trn.target.length ? trn.target : ['__all__'];
 
       for (const target of targets) {
         for (const phase of ['before', 'after'] as const) {
           if (trn[phase]) {
-            if (!set[phase]) {
-              set[phase] = new Map();
-            }
-            if (!set[phase]!.has(target)) {
-              set[phase]!.set(target, []);
-            }
-            set[phase]!.get(target)!.push(trn);
+            set.getOrInsert(phase, new Map()).getOrInsert(target, []).push(trn);
           }
         }
       }
@@ -138,11 +130,11 @@ export class VisitorFactory<S extends State = State> {
    * Handle transformer that target both ascent and descent
    */
   executePhaseAlways<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T): T | undefined {
-    if (!set[phase]?.size) {
+    if (!set.get(phase)?.size) {
       return;
     }
 
-    for (const all of set[phase]!.get('__all__') ?? []) {
+    for (const all of set.get(phase)!.get('__all__') ?? []) {
       node = all[phase]!<T>(state, node) ?? node;
     }
     return node;
@@ -152,7 +144,7 @@ export class VisitorFactory<S extends State = State> {
    * Handle a single phase of transformation
    */
   executePhase<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T): T | undefined {
-    if (!set[phase]?.size) {
+    if (!set.get(phase)?.size) {
       return;
     }
 
@@ -169,7 +161,7 @@ export class VisitorFactory<S extends State = State> {
     }
 
     for (const [key, decorator] of targets.entries()) {
-      const values = set[phase]!.get(key);
+      const values = set.get(phase)!.get(key);
       if (!values || !values.length) {
         continue;
       }