@travetto/transformer 5.0.11 → 5.0.12

package/README.md

@@ -104,10 +104,10 @@ export class Test {
 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.ts"];
+const Δfunction = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
+var mod_1 = ["@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);
+    static { Δfunction.registerFunction(TEST, mod_1, { hash: 649563175, lines: [1, 9] }, { COMPUTEAGE: { hash: 1286718349, lines: [6, 8, 7] } }, false); }
     NAME;
     AGE;
     DOB;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "5.0.11",
+  "version": "5.0.12",
   "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.10",
+    "@travetto/manifest": "^5.0.11",
     "tslib": "^2.8.1",
     "typescript": "^5.7.2"
   },

package/src/importer.ts

@@ -19,7 +19,7 @@ export class ImportManager {
   #newImports = new Map<string, Import>();
   #imports: Map<string, Import>;
   #idx: Record<string, number> = {};
-  #ids = new Map<string, string>();
+  #ids = new Map<string, ts.Identifier>();
   #importName: string;
   #resolver: TransformResolver;
 
@@ -89,7 +89,6 @@ export class ImportManager {
       false;
   }
 
-
   /**
    * Is a file or import an untyped file access
    * @param fileOrImport
@@ -101,15 +100,17 @@ export class ImportManager {
   }
 
   /**
-   * Produces a unique ID for a given file, importing if needed
+   * Produces a unique ID for a given file
    */
-  getId(file: string, name?: string): string {
+  getId(file: string, name?: string): ts.Identifier {
     if (!this.#ids.has(file)) {
       if (name) {
-        this.#ids.set(file, name);
+        this.#ids.set(file, this.factory.createIdentifier(name));
       } else {
-        const key = path.basename(file, path.extname(file)).replace(/[^A-Za-z0-9]+/g, '_');
-        this.#ids.set(file, `Ⲑ_${key}_${this.#idx[key] = (this.#idx[key] || 0) + 1}`);
+        const key = path.basename(file, path.extname(file)).replace(/\W+/g, '_');
+        const suffix = this.#idx[key] = (this.#idx[key] ?? -1) + 1;
+        // eslint-disable-next-line no-bitwise
+        this.#ids.set(file, this.factory.createIdentifier(`Δ${key}${suffix ? suffix : ''}`));
       }
     }
     return this.#ids.get(file)!;
@@ -131,15 +132,15 @@ export class ImportManager {
     }
 
     if (!D_OR_D_TS_EXT_RE.test(file) && !this.#newImports.has(file)) {
-      const id = this.getId(file, name);
+      const ident = this.getId(file, name);
+      const uniqueName = ident.text;
 
-      if (this.#imports.has(id)) { // Already imported, be cool
-        return this.#imports.get(id)!;
+      if (this.#imports.has(uniqueName)) { // Already imported, be cool
+        return this.#imports.get(uniqueName)!;
       }
 
-      const ident = this.factory.createIdentifier(id);
       const newImport = { path: file, ident };
-      this.#imports.set(ident.escapedText.toString(), newImport);
+      this.#imports.set(uniqueName, newImport);
       this.#newImports.set(file, newImport);
     }
     return this.#newImports.get(file)!;
@@ -156,7 +157,7 @@ export class ImportManager {
       switch (type.key) {
         case 'managed':
         case 'literal': this.importFromResolved(...type.typeArguments || []); break;
-        case 'union':
+        case 'composition':
         case 'tuple': this.importFromResolved(...type.subTypes || []); break;
         case 'shape': this.importFromResolved(...Object.values(type.fieldTypes)); break;
       }

package/src/register.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameⲐ } from './types/visitor';
+import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameSymbol } from './types/visitor';
 
 const HandlersProp = Symbol.for('@travetto/transformer:handlers');
 
@@ -18,7 +18,7 @@ export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTr
   return Object.values(obj)
     .flatMap(x => {
       if (isTransformer(x)) {
-        x[ModuleNameⲐ] = module;
+        x[ModuleNameSymbol] = module;
       }
       return (x[HandlersProp] ?? []);
     })

package/src/resolver/builder.ts

@@ -9,7 +9,7 @@ import { DeclarationUtil } from '../util/declaration';
 import { LiteralUtil } from '../util/literal';
 import { transformCast, TemplateLiteralPart } from '../types/shared';
 
-import { Type, AnyType, UnionType, TransformResolver, TemplateType } from './types';
+import { Type, AnyType, CompositionType, TransformResolver, TemplateType } from './types';
 import { CoerceUtil } from './coerce';
 
 const TYPINGS_RE = /[.]d[.][cm]?ts$/;
@@ -39,7 +39,7 @@ const GLOBAL_SIMPLE: Record<string, Function> = {
 type Category =
   'void' | 'undefined' | 'concrete' | 'unknown' |
   'tuple' | 'shape' | 'literal' | 'template' | 'managed' |
-  'union' | 'foreign';
+  'composition' | 'foreign';
 
 /**
  * Type categorizer, input for builder
@@ -98,12 +98,14 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     ts.TypeFlags.Void | ts.TypeFlags.Undefined
   )) {
     return { category: 'literal', type };
-  } else if (type.isUnion()) {
-    return { category: 'union', type };
+  } else if (type.isUnionOrIntersection()) {
+    return { category: 'composition', type };
   } else if (objectFlags & ts.ObjectFlags.Tuple) {
     return { category: 'tuple', type };
   } else if (type.isLiteral()) {
     return { category: 'shape', type };
+  } else if ((objectFlags & ts.ObjectFlags.Mapped)) { // Mapped types: Pick, Omit, Exclude, Retain
+    return { category: 'shape', type };
   }
   return { category: 'literal', type };
 }
@@ -207,21 +209,21 @@ export const TypeBuilder: {
       return { key: 'managed', name, importName, tsTypeArguments };
     }
   },
-  union: {
-    build: (resolver, uType: ts.UnionType) => {
+  composition: {
+    build: (resolver, uType: ts.UnionOrIntersectionType) => {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
         const u = (ut.getFlags() & (ts.TypeFlags.Undefined)) > 0;
         const n = (ut.getFlags() & (ts.TypeFlags.Null)) > 0;
-        undefinable = undefinable || u;
-        nullable = nullable || n;
+        undefinable ||= u;
+        nullable ||= n;
         return !(u || n);
       });
       const name = CoreUtil.getSymbol(uType)?.getName();
-      return { key: 'union', name, undefinable, nullable, tsSubTypes: remainder, subTypes: [] };
+      return { key: 'composition', name, undefinable, nullable, tsSubTypes: remainder, subTypes: [], operation: uType.isUnion() ? 'or' : 'and' };
     },
-    finalize: (type: UnionType) => {
+    finalize: (type: CompositionType) => {
       const { undefinable, nullable, subTypes } = type;
       const [first] = subTypes;
 
@@ -237,6 +239,8 @@ export const TypeBuilder: {
         return { undefinable, nullable, ...first };
       } else if (first.key === 'literal' && subTypes.every(el => el.name === first.name)) { // We have a common
         type.commonType = first;
+      } else if (type.operation === 'and' && first.key === 'shape' && subTypes.every(el => el.key === 'shape')) { // All shapes
+        return { importName: first.importName, name: first.name, key: 'shape', fieldTypes: subTypes.reduce((acc, x) => ({ ...acc, ...x.fieldTypes }), {}) };
       }
       return type;
     }

package/src/resolver/types.ts

@@ -117,7 +117,7 @@ export interface TemplateType extends Type<'template'> {
 /**
  * Union type
  */
-export interface UnionType extends Type<'union'> {
+export interface CompositionType extends Type<'composition'> {
   /**
    * A common type if derivable, e.g. 'a'|'b' will have a common type of string
    */
@@ -130,6 +130,10 @@ export interface UnionType extends Type<'union'> {
    * Type Info
    */
   tsSubTypes?: ts.Type[];
+  /**
+   * Operation to perform
+   */
+  operation?: 'and' | 'or';
 }
 
 /**
@@ -177,7 +181,7 @@ export interface ForeignType extends Type<'foreign'> {
 export interface UnknownType extends Type<'unknown'> { }
 
 export type AnyType =
-  TupleType | ShapeType | UnionType | LiteralType |
+  TupleType | ShapeType | CompositionType | LiteralType |
   ManagedType | PointerType | UnknownType | ForeignType | TemplateType;
 
 /**

package/src/state.ts

@@ -2,8 +2,8 @@ import ts from 'typescript';
 
 import { path, ManifestIndex } from '@travetto/manifest';
 
-import { ManagedType, AnyType, ForeignType } from './resolver/types';
-import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
+import { ManagedType, AnyType } from './resolver/types';
+import { State, DecoratorMeta, Transformer, ModuleNameSymbol } from './types/visitor';
 import { SimpleResolver } from './resolver/service';
 import { ImportManager } from './importer';
 import { Import } from './types/shared';
@@ -23,12 +23,14 @@ function hasEscapedName(n: ts.Node): n is ts.Node & { name: { escapedText: strin
   return !!n && 'name' in n && typeof n.name === 'object' && !!n.name && 'escapedText' in n.name && !!n.name.escapedText;
 }
 
+function isRedefinableDeclaration(x: ts.Node): x is ts.InterfaceDeclaration | ts.ClassDeclaration | ts.FunctionDeclaration {
+  return ts.isFunctionDeclaration(x) || ts.isClassDeclaration(x) || ts.isInterfaceDeclaration(x);
+}
+
 /**
  * Transformer runtime state
  */
 export class TransformerState implements State {
-  static SYNTHETIC_EXT = 'Ⲑsyn';
-
   #resolver: SimpleResolver;
   #imports: ImportManager;
   #modIdent: ts.Identifier;
@@ -268,7 +270,7 @@ export class TransformerState implements State {
    */
   getModuleIdentifier(): ts.Expression {
     if (this.#modIdent === undefined) {
-      this.#modIdent = this.createIdentifier('ᚕm');
+      this.#modIdent = this.factory.createUniqueName('mod');
       const entry = this.#resolver.getFileImport(this.source.fileName);
       const decl = this.factory.createVariableDeclaration(this.#modIdent, undefined, undefined,
         this.fromLiteral([entry?.module, entry?.relativeFile ?? ''])
@@ -288,7 +290,7 @@ export class TransformerState implements State {
    * @param module
    */
   findDecorator(mod: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
-    mod = typeof mod === 'string' ? mod : mod[ModuleNameⲐ]!;
+    mod = typeof mod === 'string' ? mod : mod[ModuleNameSymbol]!;
     const target = `${mod}:${name}`;
     const list = this.getDecoratorList(node);
     return list.find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
@@ -299,7 +301,7 @@ export class TransformerState implements State {
    * @param node
    * @param type
    */
-  generateUniqueIdentifier(node: ts.Node, type: AnyType): string {
+  generateUniqueIdentifier(node: ts.Node, type: AnyType, suffix?: string): string {
     let unique: string[] = [];
     let name = type.name && !type.name.startsWith('_') ? type.name : '';
     if (!name && hasEscapedName(node)) {
@@ -315,14 +317,15 @@ export class TransformerState implements State {
       if (fileName === this.source.fileName) { // if in same file suffix with location
         let child: ts.Node = tgt;
         while (child && !ts.isSourceFile(child)) {
-          if (ts.isFunctionDeclaration(child) || ts.isMethodDeclaration(child) || ts.isClassDeclaration(child) || ts.isInterfaceDeclaration(child)) {
+          if (isRedefinableDeclaration(child) || ts.isMethodDeclaration(child) || ts.isParameter(child)) {
             if (child.name) {
               unique.push(child.name.getText());
             }
           }
           child = child.parent;
         }
-        if (!unique.length) { // a top level type
+
+        if (!unique.length) {
           unique.push(ts.getLineAndCharacterOfPosition(tgt.getSourceFile(), tgt.getStart()).line.toString());
         }
       } else {
@@ -334,7 +337,7 @@ export class TransformerState implements State {
 
     if (unique.length) { // Make unique to file
       unique.unshift(this.#resolver.getFileImportName(this.source.fileName));
-      return `${name}__${SystemUtil.naiveHashString(unique.join(':'), 12)}`;
+      return `${name}__${SystemUtil.naiveHashString(unique.join(':'), 12)}${suffix || ''}`;
     } else {
       return name;
     }
@@ -343,8 +346,7 @@ export class TransformerState implements State {
   /**
    * Register synthetic identifier
    */
-  createSyntheticIdentifier(id: string): [identifier: ts.Identifier, exists: boolean] {
-    id = `${id}${TransformerState.SYNTHETIC_EXT}`;
+  registerIdentifier(id: string): [identifier: ts.Identifier, exists: boolean] {
     let exists = true;
     if (!this.#syntheticIdentifiers.has(id)) {
       this.#syntheticIdentifiers.set(id, this.factory.createIdentifier(id));
@@ -381,13 +383,4 @@ export class TransformerState implements State {
   getFileImportName(file: string): string {
     return this.#resolver.getFileImportName(file);
   }
-
-  /**
-   * Get foreign target
-   */
-  getForeignTarget(state: TransformerState, ret: ForeignType): ts.Expression {
-    return state.fromLiteral({
-      Ⲑid: `${ret.source.split('node_modules/')[1]}+${ret.name}`
-    });
-  }
 }

package/src/types/shared.ts

@@ -26,7 +26,6 @@ export type Import = {
   stmt?: ts.ImportDeclaration;
 };
 
-
 /** Template Literal Types */
 export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
 export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };

package/src/types/visitor.ts

@@ -26,10 +26,10 @@ export type TransformerType =
   'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' |
   'static-method' | 'call' | 'function' | 'file';
 
-export const ModuleNameⲐ = Symbol.for('@travetto/transformer:id');
+export const ModuleNameSymbol = Symbol.for('@travetto/transformer:id');
 
 export type Transformer = {
-  [ModuleNameⲐ]?: string;
+  [ModuleNameSymbol]?: string;
   name: string;
 };