@travetto/transformer 8.0.0-alpha.8 → 8.0.0

package/src/resolver/builder.ts

@@ -1,16 +1,24 @@
-/* eslint-disable no-bitwise */
 import ts from 'typescript';
 
-import { path, ManifestModuleUtil } from '@travetto/manifest';
+import { ManifestModuleUtil, path } from '@travetto/manifest';
 
-import { DocUtil } from '../util/doc.ts';
+import { type TemplateLiteralPart, transformCast } from '../types/shared.ts';
 import { CoreUtil } from '../util/core.ts';
 import { DeclarationUtil } from '../util/declaration.ts';
+import { DocUtil } from '../util/doc.ts';
 import { LiteralUtil } from '../util/literal.ts';
-import { transformCast, type TemplateLiteralPart } from '../types/shared.ts';
-
-import type { Type, AnyType, CompositionType, TransformResolver, TemplateType, MappedType, ShapeType, ResolverContext, ManagedType } from './types.ts';
 import { CoerceUtil } from './coerce.ts';
+import type {
+  AnyType,
+  CompositionType,
+  ManagedType,
+  MappedType,
+  ResolverContext,
+  ShapeType,
+  TemplateType,
+  TransformResolver,
+  Type
+} from './types.ts';
 
 const UNDEFINED = Symbol();
 
@@ -29,11 +37,15 @@ const getMappedFields = (type: ts.Type): string[] | undefined => {
  * List of global types that can be parameterized
  */
 const GLOBAL_COMPLEX: Record<string, Function> = {
-  Array, Promise, Set, Map, ReadonlyArray: Array,
-  Iterator: function Iterator() { },
-  Iterable: function Iterable() { },
-  IterableIterator: function IterableIterator() { },
-  AsyncIterator: function AsyncIterator() { },
+  Array,
+  Promise,
+  Set,
+  Map,
+  ReadonlyArray: Array,
+  Iterator: function Iterator() {},
+  Iterable: function Iterable() {},
+  IterableIterator: function IterableIterator() {},
+  AsyncIterator: function AsyncIterator() {},
   PropertyDescriptor: Object,
   TypedPropertyDescriptor: Object
 };
@@ -44,12 +56,29 @@ 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, BigInt,
-  ArrayBuffer, SharedArrayBuffer,
-  Uint8Array, Uint16Array, Uint32Array,
-  Int8Array, Int16Array, Int32Array,
-  Uint8ClampedArray, BigInt64Array, BigUint64Array,
-  Float16Array, Float32Array, Float64Array,
+  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
 };
 
@@ -58,27 +87,30 @@ type Category = Exclude<AnyType['key'], 'pointer'> | 'concrete';
 /**
  * Type categorizer, input for builder
  */
-export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { category: Category, type: ts.Type } {
+export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { category: Category; type: ts.Type } {
   const flags = type.getFlags();
   const objectFlags = DeclarationUtil.getObjectFlags(type) ?? 0;
 
-  if (flags & (ts.TypeFlags.TemplateLiteral)) {
+  if (flags & ts.TypeFlags.TemplateLiteral) {
     return { category: 'template', type };
-  } else if (flags & (
-    ts.TypeFlags.BigIntLike |
-    ts.TypeFlags.BooleanLike |
-    ts.TypeFlags.NumberLike |
-    ts.TypeFlags.StringLike |
-    ts.TypeFlags.Null |
-    ts.TypeFlags.Undefined |
-    ts.TypeFlags.Void
-  )) {
+  } else if (
+    flags &
+    (ts.TypeFlags.BigIntLike |
+      ts.TypeFlags.BooleanLike |
+      ts.TypeFlags.NumberLike |
+      ts.TypeFlags.StringLike |
+      ts.TypeFlags.Null |
+      ts.TypeFlags.Undefined |
+      ts.TypeFlags.Void)
+  ) {
     return { category: 'literal', type };
   } else if (DocUtil.hasDocTag(type, 'concrete')) {
     return { category: 'concrete', type };
-  } else if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) { // Any or unknown
+  } else if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+    // Any or unknown
     return { category: 'unknown', type };
-  } else if (objectFlags & ts.ObjectFlags.Reference && !CoreUtil.getSymbol(type)) { // Tuple type?
+  } else if (objectFlags & ts.ObjectFlags.Reference && !CoreUtil.getSymbol(type)) {
+    // Tuple type?
     return { category: 'tuple', type };
   } else if (type.isUnionOrIntersection()) {
     return { category: 'composition', type };
@@ -89,12 +121,10 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
       if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_REGEX.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
         return { category: 'foreign', type };
       }
-    } catch { }
+    } catch {}
 
     const text = resolver.getTypeAsString(type);
-    if (flags & (ts.SymbolFlags.TypeAlias | ts.SymbolFlags.ExportValue)
-      && text?.startsWith('typeof')
-    ) {
+    if (flags & (ts.SymbolFlags.TypeAlias | ts.SymbolFlags.ExportValue) && text?.startsWith('typeof')) {
       return { category: 'managed', type };
     }
     return { category: 'shape', type };
@@ -114,7 +144,8 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
       return { category: 'literal', type };
     } else if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_REGEX.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
       return { category: 'foreign', type: resolvedType };
-    } else if (!resolvedType.isClass()) { // Not a real type
+    } else if (!resolvedType.isClass()) {
+      // Not a real type
       return { category: 'shape', type: resolvedType };
     } else {
       return { category: 'managed', type: resolvedType };
@@ -123,7 +154,8 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     return { category: 'tuple', type };
   } else if (type.isLiteral()) {
     return { category: 'shape', type };
-  } else if (objectFlags & ts.ObjectFlags.Mapped) { // Mapped types
+  } else if (objectFlags & ts.ObjectFlags.Mapped) {
+    // Mapped types
     if (type.getProperties().some(property => property.declarations || property.valueDeclaration)) {
       return { category: 'mapped', type };
     }
@@ -138,7 +170,7 @@ export const TypeBuilder: {
   [K in Category]: {
     build(resolver: TransformResolver, type: ts.Type, context: ResolverContext): AnyType | undefined;
     finalize?(type: Type<K>): AnyType;
-  }
+  };
 } = {
   unknown: {
     build: (resolver, type) => {
@@ -154,8 +186,8 @@ export const TypeBuilder: {
       // If we are have a template literal type, we need to make our own type node
       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;
+        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') {
@@ -163,15 +195,23 @@ export const TypeBuilder: {
             }
             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;
+                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: { operation: 'and', values }, ctor: String });
+            return { key: 'template', template: { operation: 'and', values }, ctor: String };
           }
         }
       }
@@ -188,8 +228,7 @@ export const TypeBuilder: {
         return { key: 'literal', ctor: undefined, name };
       } else if (name in GLOBAL_SIMPLE) {
         const cons = GLOBAL_SIMPLE[name];
-        const literal = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, transformCast(cons), false) :
-          undefined;
+        const literal = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, transformCast(cons), false) : undefined;
 
         return {
           key: 'literal',
@@ -233,8 +272,8 @@ export const TypeBuilder: {
 
       // Detect managed, but shapeable
       if (tsTypeArguments.length > 0) {
-        const hasEmptyConstructor = type.getConstructSignatures().some(signature => signature.parameters.length === 0)
-          || type.getConstructSignatures().length === 0; // If no constructor, we can assume it's shapeable
+        const hasEmptyConstructor =
+          type.getConstructSignatures().some(signature => signature.parameters.length === 0) || type.getConstructSignatures().length === 0; // If no constructor, we can assume it's shapeable
         const hasMethods = type.getProperties().some(property => property.getFlags() & ts.SymbolFlags.Method);
         if (hasEmptyConstructor && !hasMethods && allowsVirtualTemplate(type)) {
           return TypeBuilder.shape.build(resolver, type, {
@@ -246,26 +285,35 @@ export const TypeBuilder: {
       }
 
       return managedType;
-    },
+    }
   },
   composition: {
     build: (resolver, uType: ts.UnionOrIntersectionType) => {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
-        const isUndefined = (ut.getFlags() & (ts.TypeFlags.Undefined)) > 0;
-        const isNull = (ut.getFlags() & (ts.TypeFlags.Null)) > 0;
+        const isUndefined = (ut.getFlags() & ts.TypeFlags.Undefined) > 0;
+        const isNull = (ut.getFlags() & ts.TypeFlags.Null) > 0;
         undefinable ||= isUndefined;
         nullable ||= isNull;
         return !(isUndefined || isNull);
       });
       const name = CoreUtil.getSymbol(uType)?.getName();
-      return { key: 'composition', name, undefinable, nullable, tsSubTypes: remainder, subTypes: [], operation: uType.isUnion() ? 'or' : 'and' };
+      return {
+        key: 'composition',
+        name,
+        undefinable,
+        nullable,
+        tsSubTypes: remainder,
+        subTypes: [],
+        operation: uType.isUnion() ? 'or' : 'and'
+      };
     },
     finalize: (type: CompositionType) => {
       const { undefinable, nullable, subTypes } = type;
 
-      if (subTypes.length === 0) { // We have an unknown type?
+      if (subTypes.length === 0) {
+        // We have an unknown type?
         return { key: 'unknown', nullable, undefinable };
       }
 
@@ -281,14 +329,16 @@ export const TypeBuilder: {
         };
       } else if (subTypes.length === 1) {
         return { undefinable, nullable, ...first };
-      } else if (first.key === 'literal' && subTypes.every(item => item.name === first.name)) { // We have a common
+      } else if (first.key === 'literal' && subTypes.every(item => item.name === first.name)) {
+        // We have a common
         type.commonType = first;
-      } else if (type.operation === 'and' && first.key === 'shape' && subTypes.every(item => item.key === 'shape')) { // All shapes
+      } else if (type.operation === 'and' && first.key === 'shape' && subTypes.every(item => item.key === 'shape')) {
+        // All shapes
         return {
           importName: first.importName,
           name: first.name,
           key: 'shape',
-          fieldTypes: subTypes.reduce((map, subType) => ({ ...map, ...subType.fieldTypes }), {})
+          fieldTypes: subTypes.reduce((map, subType) => Object.assign(map, { ...subType.fieldTypes }), {})
         };
       }
       return type;
@@ -313,7 +363,7 @@ export const TypeBuilder: {
       } else if (type.aliasTypeArguments && type.aliasSymbol) {
         mainType = type.aliasTypeArguments[0];
         operation = type.aliasSymbol.escapedName.toString();
-        fields = (type.aliasTypeArguments.length > 1) ? getMappedFields(type.aliasTypeArguments[1]) : [];
+        fields = type.aliasTypeArguments.length > 1 ? getMappedFields(type.aliasTypeArguments[1]) : [];
         name = `${resolver.getTypeAsString(mainType)!}_${operation}_${fields?.join('_')}`;
       }
 
@@ -341,13 +391,14 @@ export const TypeBuilder: {
 
       for (const member of properties) {
         const declaration = DeclarationUtil.getPrimaryDeclarationNode(member);
-        if (DeclarationUtil.isPublic(declaration)) { // IF public
+        if (DeclarationUtil.isPublic(declaration)) {
+          // IF public
           const memberType = resolver.getType(declaration);
           if (
             !member.getName().includes('@') && // if not a symbol
             !memberType.getCallSignatures().length // if not a function
           ) {
-            if ((ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) && !!declaration.questionToken) {
+            if ((ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) && declaration.questionToken) {
               Object.defineProperty(memberType, UNDEFINED, { value: true });
             }
             tsFieldTypes[member.getName()] = memberType;
@@ -355,8 +406,14 @@ export const TypeBuilder: {
         }
       }
       return {
-        key: 'shape', name, importName, tsFieldTypes, tsTypeArguments,
-        fieldTypes: {}, extendsFrom: context.extendsFrom, canTemplate: allowsVirtualTemplate(type)
+        key: 'shape',
+        name,
+        importName,
+        tsFieldTypes,
+        tsTypeArguments,
+        fieldTypes: {},
+        extendsFrom: context.extendsFrom,
+        canTemplate: allowsVirtualTemplate(type)
       };
     },
     finalize: (type: ShapeType) => {
@@ -390,9 +447,12 @@ export const TypeBuilder: {
 
       // Resolving relative to source file
       if (!importName || importName.startsWith('.')) {
-        const rawSourceFile: string = DeclarationUtil.getDeclarations(type)
-          ?.find(declaration => ts.getAllJSDocTags(declaration, (node): node is ts.JSDocTag => node.tagName.getText() === 'concrete').length)
-          ?.getSourceFile().fileName ?? '';
+        const rawSourceFile: string =
+          DeclarationUtil.getDeclarations(type)
+            ?.find(
+              declaration => ts.getAllJSDocTags(declaration, (node): node is ts.JSDocTag => node.tagName.getText() === 'concrete').length
+            )
+            ?.getSourceFile().fileName ?? '';
 
         if (!importName || importName === '.') {
           importName = resolver.getFileImportName(rawSourceFile);
@@ -404,8 +464,9 @@ export const TypeBuilder: {
 
       // Convert name to $Concrete suffix if not provided
       if (!name) {
-        const [primaryDeclaration] = DeclarationUtil.getDeclarations(type)
-          .filter(declaration => ts.isInterfaceDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration));
+        const [primaryDeclaration] = DeclarationUtil.getDeclarations(type).filter(
+          declaration => ts.isInterfaceDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration)
+        );
         name = `${primaryDeclaration.name.text}$Concrete`;
       }
 

package/src/resolver/cache.ts

@@ -1,4 +1,5 @@
 import type ts from 'typescript';
+
 import type { AnyType } from './types.ts';
 
 /**

package/src/resolver/coerce.ts

@@ -1,15 +1,17 @@
-const REGEX_PATTERN = /[\/](.*)[\/](i|g|m|s)?/;
+const REGEX_PATTERN = /[/](.*)[/](i|g|m|s)?/;
 
 export class CoerceUtil {
   /**
    * Is a value a plain JS object, created using {}
    */
   static #isPlainObject(value: unknown): value is Record<string, unknown> {
-    return typeof value === 'object' // separate from primitives
-      && value !== undefined
-      && value !== null         // is obvious
-      && value.constructor === Object // separate instances (Array, DOM, ...)
-      && Object.prototype.toString.call(value) === '[object Object]'; // separate build-in like Math
+    return (
+      typeof value === 'object' && // separate from primitives
+      value !== undefined &&
+      value !== null && // is obvious
+      value.constructor === Object && // separate instances (Array, DOM, ...)
+      Object.prototype.toString.call(value) === '[object Object]'
+    ); // separate build-in like Math
   }
 
   /**
@@ -50,8 +52,7 @@ export class CoerceUtil {
 
     switch (type) {
       case Date: {
-        const value = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
-          new Date(parseInt(`${input}`, 10)) : new Date(`${input}`);
+        const value = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ? new Date(parseInt(`${input}`, 10)) : new Date(`${input}`);
         if (strict && Number.isNaN(value.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
@@ -106,8 +107,9 @@ export class CoerceUtil {
         }
       }
       case undefined:
-      case String: return `${input}`;
+      case String:
+        return `${input}`;
     }
     throw new Error(`Unknown type ${type.name}`);
   }
-}
+}

package/src/resolver/service.ts

@@ -1,13 +1,13 @@
 import ts from 'typescript';
 
-import { path, type ManifestIndex, ManifestModuleUtil, type IndexedFile } from '@travetto/manifest';
+import { type IndexedFile, type ManifestIndex, ManifestModuleUtil, path } from '@travetto/manifest';
 
-import type { AnyType, ResolverContext, TransformResolver } from './types.ts';
-import { TypeCategorize, TypeBuilder } from './builder.ts';
-import { VisitCache } from './cache.ts';
-import { DocUtil } from '../util/doc.ts';
-import { DeclarationUtil } from '../util/declaration.ts';
 import { transformCast } from '../types/shared.ts';
+import { DeclarationUtil } from '../util/declaration.ts';
+import { DocUtil } from '../util/doc.ts';
+import { TypeBuilder, TypeCategorize } from './builder.ts';
+import { VisitCache } from './cache.ts';
+import type { AnyType, ResolverContext, TransformResolver } from './types.ts';
 
 const isFinalizeType = (key: string): key is keyof typeof TypeBuilder => key in TypeBuilder;
 
@@ -45,8 +45,10 @@ export class SimpleResolver implements TransformResolver {
 
     const sourceType = ManifestModuleUtil.getFileType(sourceFile);
 
-    return this.#manifestIndex.getEntry((sourceType === 'ts' || sourceType === 'js') ? sourceFile : undefined!) ??
-      this.#manifestIndex.getFromImport(ManifestModuleUtil.withoutSourceExtension(sourceFile).replace(/^.*node_modules\//, ''));
+    return (
+      this.#manifestIndex.getEntry(sourceType === 'ts' || sourceType === 'js' ? sourceFile : undefined!) ??
+      this.#manifestIndex.getFromImport(ManifestModuleUtil.withoutSourceExtension(sourceFile).replace(/^.*node_modules\//, ''))
+    );
   }
 
   /**
@@ -69,8 +71,7 @@ export class SimpleResolver implements TransformResolver {
    * Is the file/import known to the index, helpful for determine ownership
    */
   isKnownFile(fileOrImport: string): boolean {
-    return (this.#manifestIndex.getFromSource(fileOrImport) !== undefined) ||
-      (this.#manifestIndex.getFromImport(fileOrImport) !== undefined);
+    return this.#manifestIndex.getFromSource(fileOrImport) !== undefined || this.#manifestIndex.getFromImport(fileOrImport) !== undefined;
   }
 
   /**
@@ -116,7 +117,8 @@ export class SimpleResolver implements TransformResolver {
    * Get list of properties
    */
   getPropertiesOfType(type: ts.Type): ts.Symbol[] {
-    return this.#tsChecker.getPropertiesOfType(type)
+    return this.#tsChecker
+      .getPropertiesOfType(type)
       .filter(property => property.getName() !== '__proto__' && property.getName() !== 'prototype');
   }
 
@@ -128,7 +130,8 @@ export class SimpleResolver implements TransformResolver {
     const resolve = (resType: ts.Type, context?: Omit<ResolverContext, 'node' | 'importName'>): AnyType => {
       const { depth = 0 } = context ?? {};
 
-      if (depth > 20) { // Max depth is 20
+      if (depth > 20) {
+        // Max depth is 20
         throw new Error(`Object structure too nested: ${'getText' in node ? node.getText() : ''}`);
       }
 
@@ -137,7 +140,7 @@ export class SimpleResolver implements TransformResolver {
       const typeArguments: ts.Type[] =
         'resolvedTypeArguments' in resType && resType.resolvedTypeArguments ? transformCast(resType.resolvedTypeArguments) : [];
 
-      let result = TypeBuilder[category].build(this, type, { ...context, node: (node && 'kind' in node) ? node : undefined, importName });
+      let result = TypeBuilder[category].build(this, type, { ...context, node: node && 'kind' in node ? node : undefined, importName });
 
       // Convert via cache if needed
       result = visited.getOrSet(type, result);
@@ -148,15 +151,19 @@ export class SimpleResolver implements TransformResolver {
         result.templateTypeName = context?.templateTypeName;
 
         try {
-          result.comment = DocUtil.describeDocs(type).description;
-        } catch { }
+          result.description = DocUtil.describeDocs(type).description;
+        } catch {}
 
         if ('tsTypeArguments' in result) {
           const tsTypeArguments = result.tsTypeArguments!;
           if (typeArguments.length) {
-            result.typeArguments = typeArguments.map((item, i) => resolve(item, { alias: type.aliasSymbol, templateTypeName: tsTypeArguments[i][0], depth: depth + 1 }));
+            result.typeArguments = typeArguments.map((item, i) =>
+              resolve(item, { alias: type.aliasSymbol, templateTypeName: tsTypeArguments[i][0], depth: depth + 1 })
+            );
           } else {
-            result.typeArguments = tsTypeArguments.map((item) => resolve(item[1], { alias: type.aliasSymbol, templateTypeName: item[0], depth: depth + 1 }));
+            result.typeArguments = tsTypeArguments.map(item =>
+              resolve(item[1], { alias: type.aliasSymbol, templateTypeName: item[0], depth: depth + 1 })
+            );
           }
           delete result.tsTypeArguments;
         }
@@ -169,7 +176,7 @@ export class SimpleResolver implements TransformResolver {
           delete result.tsFieldTypes;
         }
         if ('tsSubTypes' in result) {
-          result.subTypes = result.tsSubTypes!.map((item) => resolve(item, { alias: type.aliasSymbol, depth: depth + 1 }));
+          result.subTypes = result.tsSubTypes!.map(item => resolve(item, { alias: type.aliasSymbol, depth: depth + 1 }));
           delete result.tsSubTypes;
         }
         if (isFinalizeType(result.key)) {
@@ -190,4 +197,4 @@ export class SimpleResolver implements TransformResolver {
       return { key: 'literal', ctor: Object, name: 'object' };
     }
   }
-}
+}

package/src/resolver/types.ts

@@ -1,4 +1,5 @@
 import type ts from 'typescript';
+
 import type { TemplateLiteral } from '../types/shared.ts';
 
 type TemplateArgument = [templateName: string, type: ts.Type];
@@ -18,7 +19,11 @@ export interface Type<K extends string> {
   /**
    * JS Doc comment
    */
-  comment?: string;
+  description?: string;
+  /**
+   * JS Doc examples
+   */
+  examples?: string[];
   /**
    * Can be undefined
    */
@@ -218,11 +223,19 @@ export interface ForeignType extends Type<'foreign'> {
 /**
  * Unknown type, should default to object
  */
-export interface UnknownType extends Type<'unknown'> { }
+export interface UnknownType extends Type<'unknown'> {}
 
 export type AnyType =
-  TupleType | ShapeType | CompositionType | LiteralType | MappedType |
-  ManagedType | PointerType | UnknownType | ForeignType | TemplateType;
+  | TupleType
+  | ShapeType
+  | CompositionType
+  | LiteralType
+  | MappedType
+  | ManagedType
+  | PointerType
+  | UnknownType
+  | ForeignType
+  | TemplateType;
 
 /**
  * Simple interface for checked methods