@travetto/transformer 3.1.4 → 3.2.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "3.1.4",
+  "version": "3.2.0-rc.0",
   "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.1",
+    "@travetto/manifest": "^3.2.0-rc.0",
     "tslib": "^2.5.2",
     "typescript": "^5.0.4"
   },

package/src/resolver/builder.ts

@@ -7,8 +7,9 @@ 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 { Type, AnyType, UnionType, TransformResolver } from './types';
+import { Type, AnyType, UnionType, TransformResolver, TemplateType } from './types';
 import { CoerceUtil } from './coerce';
 
 /**
@@ -33,7 +34,10 @@ const GLOBAL_SIMPLE: Record<string, Function> = {
   PromiseConstructor: Promise.constructor
 };
 
-type Category = 'void' | 'undefined' | 'concrete' | 'unknown' | 'tuple' | 'shape' | 'literal' | 'managed' | 'union' | 'foreign';
+type Category =
+  'void' | 'undefined' | 'concrete' | 'unknown' |
+  'tuple' | 'shape' | 'literal' | 'template' | 'managed' |
+  'union' | 'foreign';
 
 /**
  * Type categorizer, input for builder
@@ -82,6 +86,8 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     } else {
       return { category: 'managed', type: resolvedType };
     }
+  } 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 |
@@ -120,6 +126,36 @@ export const TypeBuilder: {
   tuple: {
     build: (resolver, type) => ({ key: 'tuple', tsTupleTypes: resolver.getAllTypeArguments(type), subTypes: [] })
   },
+  template: {
+    build: (resolver, type) => {
+      // If we are have a template literal type, we need to make our own type node
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      if (type.flags & ts.TypeFlags.TemplateLiteral) {
+        const values: TemplateLiteralPart[] = [];
+        const texts = 'texts' in type && (typeof type.texts === 'object') && Array.isArray(type.texts) ? type.texts : undefined;
+        const types = 'types' in type && (typeof type.types === 'object') && Array.isArray(type.types) ? type.types : undefined;
+        if (texts?.length && types?.length) {
+          for (let i = 0; i < texts?.length; i += 1) {
+            if (texts[i] && texts[i] !== 'undefined') {
+              values.push(texts[i]);
+            }
+            if (types[i]) {
+              switch (types[i].intrinsicName) {
+                case 'number': values.push(Number); break;
+                case 'string': values.push(String); break;
+                case 'boolean': values.push(Boolean); break;
+                case 'undefined': values.push(''); break;
+              }
+            }
+          }
+          if (values.length > 0) {
+            return ({ key: 'template', template: { op: 'and', values }, ctor: String });
+          }
+        }
+      }
+      return { key: 'literal', ctor: Object };
+    }
+  },
   literal: {
     build: (resolver, type) => {
       // Handle void/undefined
@@ -182,7 +218,16 @@ export const TypeBuilder: {
       const { undefinable, nullable, subTypes } = type;
       const [first] = subTypes;
 
-      if (subTypes.length === 1) {
+      if (first.key === 'template') {
+        return {
+          key: 'template',
+          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!) }
+        };
+      } else if (subTypes.length === 1) {
         return { undefinable, nullable, ...first };
       } else if (first.key === 'literal' && subTypes.every(el => el.name === first.name)) { // We have a common
         type.commonType = first;

package/src/resolver/types.ts

@@ -1,4 +1,5 @@
 import type ts from 'typescript';
+import { TemplateLiteral } from '../types/shared';
 
 /**
  * Base type for a simplistic type structure
@@ -99,6 +100,20 @@ export interface LiteralType extends Type<'literal'> {
   tsTypeArguments?: ts.Type[];
 }
 
+/**
+ * A literal template type
+ */
+export interface TemplateType extends Type<'template'> {
+  /**
+   * Pointer to real type (String)
+   */
+  ctor: Function;
+  /**
+   * Type arguments
+   */
+  template?: TemplateLiteral;
+}
+
 /**
  * Union type
  */
@@ -161,7 +176,9 @@ export interface ForeignType extends Type<'foreign'> {
  */
 export interface UnknownType extends Type<'unknown'> { }
 
-export type AnyType = TupleType | ShapeType | UnionType | LiteralType | ManagedType | PointerType | UnknownType | ForeignType;
+export type AnyType =
+  TupleType | ShapeType | UnionType | LiteralType |
+  ManagedType | PointerType | UnknownType | ForeignType | TemplateType;
 
 /**
  * Simple interface for checked methods

package/src/types/shared.ts

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

package/src/util/literal.ts

@@ -1,5 +1,7 @@
 import ts from 'typescript';
 
+import { TemplateLiteral } from '../types/shared';
+
 /**
  * Utilities for dealing with literals
  */
@@ -41,6 +43,8 @@ export class LiteralUtil {
       val = factory.createNumericLiteral(val);
     } else if (typeof val === 'boolean') {
       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);
@@ -144,4 +148,31 @@ export class LiteralUtil {
     }
     return undefined;
   }
+
+  /**
+   * Flatten a template literal into a regex
+   */
+  static templateLiteralToRegex(template: TemplateLiteral, exact = true): string {
+    const out: string[] = [];
+    for (const el of template.values) {
+      if (el === Number) {
+        out.push('\\d+');
+      } else if (el === Boolean) {
+        out.push('(?:true|false)');
+      } else if (el === String) {
+        out.push('.+');
+      } 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)})`);
+      }
+    }
+    const body = out.join(template.op === 'and' ? '' : '|');
+    if (exact) {
+      return `^(?:${body})$`;
+    } else {
+      return body;
+    }
+  }
 }