@travetto/transformer 3.1.0-rc.2 → 3.1.0-rc.4

package/package.json

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

package/src/importer.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { PackageUtil, path } from '@travetto/manifest';
 
-import { AnyType, TransformResolver, ExternalType } from './resolver/types';
+import { AnyType, TransformResolver, ManagedType } from './resolver/types';
 import { ImportUtil } from './util/import';
 import { CoreUtil } from './util/core';
 import { Import } from './types/shared';
@@ -128,11 +128,11 @@ export class ImportManager {
    */
   importFromResolved(...types: AnyType[]): void {
     for (const type of types) {
-      if (type.key === 'external' && type.importName && type.importName !== this.#importName) {
+      if (type.key === 'managed' && type.importName && type.importName !== this.#importName) {
         this.importFile(type.importName);
       }
       switch (type.key) {
-        case 'external':
+        case 'managed':
         case 'literal': this.importFromResolved(...type.typeArguments || []); break;
         case 'union':
         case 'tuple': this.importFromResolved(...type.subTypes || []); break;
@@ -217,7 +217,7 @@ export class ImportManager {
   /**
    * Get the identifier and import if needed
    */
-  getOrImport(factory: ts.NodeFactory, type: ExternalType): ts.Identifier | ts.PropertyAccessExpression {
+  getOrImport(factory: ts.NodeFactory, type: ManagedType): ts.Identifier | ts.PropertyAccessExpression {
     if (type.importName === this.#importName) {
       return factory.createIdentifier(type.name!);
     } else {

package/src/resolver/builder.ts

@@ -33,7 +33,7 @@ const GLOBAL_SIMPLE: Record<string, Function> = {
   PromiseConstructor: Promise.constructor
 };
 
-type Category = 'void' | 'undefined' | 'concrete' | 'unknown' | 'tuple' | 'shape' | 'literal' | 'external' | 'union';
+type Category = 'void' | 'undefined' | 'concrete' | 'unknown' | 'tuple' | 'shape' | 'literal' | 'managed' | 'union' | 'foreign';
 
 /**
  * Type categorizer, input for builder
@@ -53,7 +53,13 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
   } else if (objectFlags & ts.ObjectFlags.Reference && !CoreUtil.getSymbol(type)) { // Tuple type?
     return { category: 'tuple', type };
   } else if (objectFlags & ts.ObjectFlags.Anonymous) {
-    return { category: 'shape', type };
+    const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
+    const sourceFile = source.fileName;
+    if (sourceFile?.endsWith('.d.ts') && !resolver.isKnownFile(sourceFile)) {
+      return { category: 'foreign', type };
+    } else {
+      return { category: 'shape', type };
+    }
   } else if (objectFlags & (ts.ObjectFlags.Reference | ts.ObjectFlags.Class | ts.ObjectFlags.Interface)) {
     let resolvedType = type;
     if (CoreUtil.hasTarget(resolvedType)) {
@@ -66,14 +72,14 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
 
     const source = DeclarationUtil.getPrimaryDeclarationNode(resolvedType).getSourceFile();
     const sourceFile = source.fileName;
-    if (sourceFile?.includes('@types/node/globals') || sourceFile?.includes('typescript/lib')) {
+    if (sourceFile?.includes('typescript/lib')) {
       return { category: 'literal', type };
     } else if (sourceFile?.endsWith('.d.ts') && !resolver.isKnownFile(sourceFile)) {
-      return { category: 'unknown', type };
+      return { category: 'foreign', type: resolvedType };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
     } else {
-      return { category: 'external', type: resolvedType };
+      return { category: 'managed', type: resolvedType };
     }
   } else if (flags & (
     ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral |
@@ -142,12 +148,19 @@ export const TypeBuilder: {
       }
     }
   },
-  external: {
+  foreign: {
+    build: (resolver, type) => {
+      const name = CoreUtil.getSymbol(type)?.getName();
+      const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
+      return { key: 'foreign', name, source: source.fileName };
+    }
+  },
+  managed: {
     build: (resolver, type) => {
       const name = CoreUtil.getSymbol(type)?.getName();
       const importName = resolver.getTypeImportName(type)!;
       const tsTypeArguments = resolver.getAllTypeArguments(type);
-      return { key: 'external', name, importName, tsTypeArguments };
+      return { key: 'managed', name, importName, tsTypeArguments };
     }
   },
   union: {
@@ -226,7 +239,7 @@ export const TypeBuilder: {
             importName = resolver.getFileImportName(path.resolve(base, importName));
           }
         }
-        return { key: 'external', name, importName };
+        return { key: 'managed', name, importName };
       }
     }
   }

package/src/resolver/cache.ts

@@ -16,7 +16,7 @@ export class VisitCache {
     // Check for recursion
     switch (type?.key) {
       case 'shape':
-      case 'external': {
+      case 'managed': {
         if (this.storage.has(tsType)) {
           const target = this.storage.get(tsType)!;
           if (target.key !== 'pointer') {

package/src/resolver/types.ts

@@ -31,9 +31,9 @@ export interface Type<K extends string> {
 }
 
 /**
- * A type that is not defined in the scope of the given file
+ * A type that is not defined in the scope of the given file, but is importable from the project
  */
-export interface ExternalType extends Type<'external'> {
+export interface ManagedType extends Type<'managed'> {
   /**
    *  Location the type came from, for class references
    */
@@ -141,12 +141,27 @@ export interface PointerType extends Type<'pointer'> {
   target: Exclude<AnyType, PointerType>;
 }
 
+/**
+ * Foreign type, outside of framework
+ */
+export interface ForeignType extends Type<'foreign'> {
+  /**
+   * Identifier for type
+   */
+  name: string;
+
+  /**
+   * Primary source file
+   */
+  source: string;
+}
+
 /**
  * Unknown type, should default to object
  */
 export interface UnknownType extends Type<'unknown'> { }
 
-export type AnyType = TupleType | ShapeType | UnionType | LiteralType | ExternalType | PointerType | UnknownType;
+export type AnyType = TupleType | ShapeType | UnionType | LiteralType | ManagedType | PointerType | UnknownType | ForeignType;
 
 /**
  * Simple interface for checked methods

package/src/state.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { ManifestIndex, path } from '@travetto/manifest';
 
-import { ExternalType, AnyType } from './resolver/types';
+import { ManagedType, AnyType } from './resolver/types';
 import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
 import { SimpleResolver } from './resolver/service';
 import { ImportManager } from './importer';
@@ -53,7 +53,7 @@ export class TransformerState implements State {
   /**
    * Get or import the node or external type
    */
-  getOrImport(type: ExternalType): ts.Identifier | ts.PropertyAccessExpression {
+  getOrImport(type: ManagedType): ts.Identifier | ts.PropertyAccessExpression {
     return this.#imports.getOrImport(this.factory, type);
   }
 
@@ -76,9 +76,9 @@ export class TransformerState implements State {
   /**
    * Resolve external type
    */
-  resolveExternalType(node: ts.Node): ExternalType {
+  resolveManagedType(node: ts.Node): ManagedType {
     const resolved = this.resolveType(node);
-    if (resolved.key !== 'external') {
+    if (resolved.key !== 'managed') {
       const file = node.getSourceFile().fileName;
       const src = this.#resolver.getFileImportName(file);
       throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${src}`);
@@ -93,7 +93,7 @@ export class TransformerState implements State {
     const type = 'flags' in node ? this.resolveType(node) : node;
     switch (type.key) {
       case 'literal': return this.factory.createIdentifier(type.ctor!.name);
-      case 'external': return this.getOrImport(type);
+      case 'managed': return this.getOrImport(type);
       case 'shape': return;
     }
   }
@@ -348,4 +348,12 @@ export class TransformerState implements State {
       }
     }
   }
+
+  /**
+   * Get import name for a given file
+   * @param file
+   */
+  getFileImportName(file: string): string {
+    return this.#resolver.getFileImportName(file);
+  }
 }