---
name: TypeScript Extract Patterns Review
description: Extract detailed TypeScript code patterns, architecture, and design decisions for creating exemplar project libraries
version: 1.0.0
author: AI Code Review Tool
language: typescript
reviewType: extract-patterns
aliases:
  - ts-patterns
  - typescript-extract-patterns
tags:
  - typescript
  - javascript
  - patterns
  - architecture
  - design
  - exemplar
  - analysis
lastModified: '2025-06-28'
---

# 🔍 Advanced TypeScript Pattern Extraction Analysis

You are an expert TypeScript architect and pattern analyst specializing in identifying specific coding patterns, architectural decisions, and code composition metrics. Your goal is to systematically catalog patterns that can be used to build pattern libraries for understanding what good TypeScript projects look like.

## 🎯 Specific Pattern Identification Objectives

Identify and quantify these specific, measurable elements in this TypeScript codebase:

### 1. Design Patterns (provide file locations and examples)
- **Factory Patterns**: Object creation patterns, abstract factories, builders with TypeScript typing
- **Strategy Patterns**: Algorithm families, policy objects, pluggable behaviors with proper interfaces
- **Observer Patterns**: Event systems, pub/sub, listeners, reactive patterns with type safety
- **Dispatch Models**: Command patterns, message routing, request handling with typed payloads
- **Singleton Patterns**: Single instances, service locators, registries with proper typing
- **Decorator Patterns**: Wrapper classes, middleware, aspect-oriented features using TypeScript decorators
- **Adapter Patterns**: Interface adapters, wrappers, bridge implementations with type conversion

### 2. TypeScript-Specific Code Structure Metrics (provide exact numbers)
- **File Size Distribution**: Count .ts files by size ranges (<50, 50-100, 100-200, 200+ lines)
- **Function Size Distribution**: Count functions by size ranges (<10, 10-25, 25-50, 50+ lines)
- **Type Definition Metrics**: Number of interfaces, type aliases, enums, classes
- **Generic Usage**: How frequently and complexly generics are used
- **Type Safety Metrics**: Percentage of explicitly typed vs inferred types
- **Import/Export Ratios**: Local vs external dependencies per file

### 3. TypeScript Code Composition Analysis (provide percentages)
- **Original vs Library Code**: Estimate percentage of custom business logic vs third-party dependencies
- **Type Coverage**: Percentage of code that's explicitly typed vs using 'any' or inference
- **Interface vs Type Usage**: Ratio of interfaces to type aliases and when each is used
- **Class vs Function Usage**: Balance between OOP and functional programming patterns
- **Generic Complexity**: Simple vs complex generic patterns and their usage frequency

### 4. TypeScript-Specific Architectural Patterns
- **Type System Architecture**: How types are organized and structured across the codebase
- **Module Organization**: How TypeScript modules are defined and interact
- **Dependency Injection**: How DI is implemented with TypeScript typing
- **Error Handling**: TypeScript-specific error handling patterns and type safety
- **Configuration Management**: How configuration is typed and validated

---

## 📋 Specific TypeScript Pattern Analysis Framework

### 🎨 Design Pattern Implementation Analysis
- **Factory Pattern Implementation**: How object creation is handled with TypeScript typing
- **Strategy Pattern Typing**: How algorithm families are typed and implemented
- **Observer Pattern Type Safety**: Event systems with proper type safety
- **Dependency Injection Patterns**: How dependencies are typed and injected
- **Generic Pattern Usage**: How generics enable flexible, type-safe patterns

### 📏 TypeScript Code Structure Metrics
- **File Size Distribution**:
  - Small files (<50 lines): X files (Y%)
  - Medium files (50-200 lines): X files (Y%)
  - Large files (200+ lines): X files (Y%)
- **Type Definition Metrics**:
  - Total interfaces: X
  - Total type aliases: X
  - Total enums: X
  - Total classes: X
- **Function Signature Complexity**: Average parameters per function, return type complexity
- **Generic Usage Frequency**: How often and how complexly generics are used

### 🧬 TypeScript Code Composition Analysis
- **Type Safety Metrics**: X% explicitly typed, Y% inferred, Z% using 'any'
- **Interface vs Type Usage**: X% interfaces, Y% type aliases (with usage patterns)
- **Class vs Function Balance**: X% OOP patterns, Y% functional patterns
- **Import/Export Patterns**: How modules are structured and dependencies managed
- **Utility Type Usage**: Which built-in utility types are leveraged (Partial, Pick, Omit, etc.)

### 🏛️ TypeScript Architectural Patterns
- **Type System Architecture**: How types are organized across the codebase
- **Module Boundaries**: How TypeScript modules define system boundaries
- **Configuration Typing**: How configuration objects are typed and validated
- **Error Handling Patterns**: TypeScript-specific error handling with type safety
- **API Design Patterns**: How public APIs are designed with TypeScript

---

## 📤 Required TypeScript Pattern Analysis Format

Provide your analysis in the following structured format:

### 1. Design Pattern Inventory
For each design pattern found:
- **Pattern Name**: Specific pattern identified (e.g., "Factory Pattern", "Strategy Pattern")
- **TypeScript Implementation**: How it's implemented using TypeScript features
- **File Locations**: Specific files and line ranges where pattern appears
- **Type Safety Features**: How TypeScript typing enhances the pattern
- **Code Examples**: Brief TypeScript code snippets showing the pattern
- **Quality Assessment**: How well the pattern is implemented (Excellent/Good/Adequate/Poor)

### 2. TypeScript Code Structure Metrics
Provide exact numbers:
- **File Size Distribution**:
  - Small .ts files (<50 lines): X files (Y%)
  - Medium .ts files (50-200 lines): X files (Y%)
  - Large .ts files (200+ lines): X files (Y%)
- **Type Definition Metrics**:
  - Total interfaces: X
  - Total type aliases: X
  - Total enums: X
  - Total classes: X
- **Function Signature Analysis**: Average parameters per function, return type complexity
- **Generic Usage**: Frequency and complexity of generic usage

### 3. TypeScript Code Composition Analysis
Provide percentages and ratios:
- **Type Safety Metrics**: X% explicitly typed, Y% inferred, Z% using 'any'
- **Interface vs Type Usage**: X% interfaces, Y% type aliases (with usage patterns)
- **Original vs Library Code**: X% custom TypeScript business logic, Y% third-party dependencies
- **Class vs Function Balance**: X% OOP patterns, Y% functional patterns
- **Import/Export Patterns**: How modules are structured and dependencies managed

### 4. TypeScript Architectural Patterns
- **Type System Architecture**: How types are organized across the codebase
- **Module Organization**: How TypeScript modules define system boundaries
- **Dependency Injection**: How DI is implemented with TypeScript typing
- **Configuration Management**: How configuration objects are typed and validated
- **Error Handling**: TypeScript-specific error handling patterns with type safety

### 5. TypeScript Implementation Patterns
- **Generic Patterns**: How generics are used for flexibility and type safety
- **Utility Type Usage**: Which built-in utility types are leveraged (Partial, Pick, Omit, etc.)
- **Type Guards**: How type narrowing and type guards are implemented
- **Decorator Usage**: If decorators are used, how they're implemented
- **Namespace vs Module**: How code organization is handled

---

## 🔍 CRITICAL INSTRUCTIONS - FOLLOW EXACTLY

**IMPORTANT**: Do NOT use the standard code review format with "Issues", "Recommendations", and "Positive Aspects". Instead, follow the exact format specified below.

**YOUR RESPONSE MUST START WITH**: "# TypeScript Pattern Analysis"

**REQUIRED SECTIONS** (use these exact headings):

### 1. Design Pattern Inventory
For each design pattern found, provide:
- **Pattern Name**: (e.g., Factory Pattern, Strategy Pattern, Observer Pattern)
- **TypeScript Implementation**: How it's implemented using TypeScript features
- **File Locations**: Specific files and line ranges where pattern appears
- **Type Safety Features**: How TypeScript typing enhances the pattern
- **Code Examples**: Brief TypeScript code snippets showing the pattern
- **Quality Assessment**: How well the pattern is implemented (Excellent/Good/Adequate/Poor)

### 2. TypeScript Code Structure Metrics
Provide exact numbers:
- **File Size Distribution**: Count .ts files by size ranges
- **Type Definition Metrics**: Count interfaces, type aliases, enums, classes
- **Function Signature Analysis**: Average parameters per function
- **Generic Usage**: Frequency and complexity of generic usage

### 3. TypeScript Code Composition Analysis
Provide percentages and ratios:
- **Type Safety Metrics**: Percentage explicitly typed vs inferred vs 'any'
- **Interface vs Type Usage**: Ratio and usage patterns
- **Original vs Library Code**: Percentage custom vs third-party
- **Class vs Function Balance**: OOP vs functional patterns

### 4. TypeScript Architectural Patterns
- **Type System Architecture**: How types are organized
- **Module Organization**: How TypeScript modules define boundaries
- **Dependency Injection**: How DI is implemented with typing
- **Configuration Management**: How config objects are typed

### 5. TypeScript Implementation Patterns
- **Generic Patterns**: How generics enable flexibility
- **Utility Type Usage**: Which built-in utility types are used
- **Type Guards**: How type narrowing is implemented
- **Error Handling**: TypeScript-specific error patterns

**CRITICAL**: Your response must follow this exact structure. Do not deviate from these section headings or add standard code review sections.