1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// The Abstract Class defines the template method and declares
// abstract operations that subclasses must implement
 
abstract class AbstractClass {
    // The TEMPLATE METHOD defines the algorithm skeleton
    // It's typically 'final' (non-overridable) in languages that support it
    templateMethod(): void {
        this.baseOperation1();           // Concrete step (shared)
        this.requiredOperation1();       // Abstract step (must be implemented)
        this.baseOperation2();           // Concrete step (shared)
        this.hook();                     // Hook (optional override)
        this.requiredOperation2();       // Abstract step (must be implemented)
        this.baseOperation3();           // Concrete step (shared)
    }
    
    // Concrete operations — implemented in the base class
    // These are the INVARIANT parts of the algorithm
    protected baseOperation1(): void {
        console.log("AbstractClass: baseOperation1");
    }
    
    protected baseOperation2(): void {
        console.log("AbstractClass: baseOperation2");
    }
    
    protected baseOperation3(): void {
        console.log("AbstractClass: baseOperation3");
    }
    
    // Abstract operations — MUST be implemented by subclasses
    // These are the VARIANT parts that require customization
    protected abstract requiredOperation1(): void;
    protected abstract requiredOperation2(): void;
    
    // Hooks — CAN be overridden but have default implementations
    // These are optional customization points
    protected hook(): void {
        // Default implementation (often empty or minimal)
    }
}
 
// Concrete Classes implement the abstract operations
// They provide the variant behavior
 
class ConcreteClass1 extends AbstractClass {
    protected requiredOperation1(): void {
        console.log("ConcreteClass1: implementation of requiredOperation1");
    }
    
    protected requiredOperation2(): void {
        console.log("ConcreteClass1: implementation of requiredOperation2");
    }
    
    // ConcreteClass1 does not override hook() — uses default
}
 
class ConcreteClass2 extends AbstractClass {
    protected requiredOperation1(): void {
        console.log("ConcreteClass2: implementation of requiredOperation1");
    }
    
    protected requiredOperation2(): void {
        console.log("ConcreteClass2: implementation of requiredOperation2");
    }
    
    // ConcreteClass2 DOES override the hook
    protected hook(): void {
        console.log("ConcreteClass2: overridden hook");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

abstract class DocumentExporter {
    // Concrete operation: same for all exporters
    protected gatherData(source: DataSource): EnrichedData {
        console.log("Gathering data from source...");
        const rawData = source.fetchAll();
        const enriched = this.enrichData(rawData);
        console.log(`Gathered ${enriched.records.length} records`);
        return enriched;
    }
    
    // Another concrete operation: same for all
    protected notifyCompletion(filename: string): void {
        console.log(`Export completed: ${filename}`);
        this.eventBus.emit('export:complete', { filename });
    }
    
    // Private helper — internal implementation detail
    private enrichData(raw: RawData): EnrichedData {
        return { records: raw.items.map(item => ({ ...item, processed: true })) };
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

abstract class DocumentExporter {
    // Abstract operation: each format implements differently
    protected abstract writeHeader(stream: OutputStream): void;
    
    // Abstract operation: each format renders content differently
    protected abstract writeBody(stream: OutputStream, data: EnrichedData): void;
    
    // Abstract operation: each format has different closing
    protected abstract writeFooter(stream: OutputStream): void;
    
    // Abstract operation: each format has a different file extension
    protected abstract getFileExtension(): string;
}
 
// Concrete implementation for PDF
class PdfExporter extends DocumentExporter {
    protected writeHeader(stream: OutputStream): void {
        stream.write("%PDF-1.4\n");
        stream.write("%\xE2\xE3\xCF\xD3\n");
    }
    
    protected writeBody(stream: OutputStream, data: EnrichedData): void {
        const pdfContent = this.renderAsPdf(data);
        stream.write(pdfContent);
    }
    
    protected writeFooter(stream: OutputStream): void {
        stream.write("%%EOF\n");
    }
    
    protected getFileExtension(): string {
        return "pdf";
    }
    
    private renderAsPdf(data: EnrichedData): string {
        // PDF-specific rendering logic
        return `... PDF content for ${data.records.length} records ...`;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

abstract class DocumentExporter {
    // Hook: optional customization before export starts
    // Default: do nothing
    protected beforeExport(): void {
        // Default implementation: empty
    }
    
    // Hook: optional customization after export completes
    // Default: do nothing
    protected afterExport(): void {
        // Default implementation: empty
    }
    
    // Hook: optional validation step
    // Default: all data is valid
    protected validateData(data: EnrichedData): boolean {
        return true;  // Default: no validation
    }
    
    // Hook: optional metadata injection
    // Default: empty metadata
    protected getMetadata(): Record<string, string> {
        return {};
    }
    
    // The template method uses these hooks
    public exportDocument(source: DataSource, filename: string): void {
        this.beforeExport();  // Hook call
        
        const data = this.gatherData(source);
        
        if (!this.validateData(data)) {  // Hook call
            throw new Error("Data validation failed");
        }
        
        const stream = this.openStream(`${filename}.${this.getFileExtension()}`);
        this.writeHeader(stream);
        this.writeBody(stream, data);
        this.writeFooter(stream);
        this.closeStream(stream);
        
        this.afterExport();  // Hook call
        this.notifyCompletion(filename);
    }
}
 
// LoggingPdfExporter overrides hooks for audit purposes
class LoggingPdfExporter extends PdfExporter {
    protected beforeExport(): void {
        console.log(`[AUDIT] Export initiated at ${new Date().toISOString()}`);
    }
    
    protected afterExport(): void {
        console.log(`[AUDIT] Export completed at ${new Date().toISOString()}`);
    }
    
    // Does NOT override validateData — uses default (true)
}
 
// ValidatingPdfExporter adds custom validation
class ValidatingPdfExporter extends PdfExporter {
    protected validateData(data: EnrichedData): boolean {
        if (data.records.length === 0) {
            console.warn("Warning: exporting empty document");
            return false;
        }
        return data.records.every(r => r.id != null);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

// ============================================
// Types and Interfaces
// ============================================
 
interface DataSource {
    fetchAll(): RawData;
}
 
interface RawData {
    items: Array<{ id: string; content: string }>;
    timestamp: Date;
}
 
interface EnrichedData {
    records: Array<{ id: string; content: string; processed: boolean }>;
    metadata: Record<string, string>;
}
 
interface OutputStream {
    write(content: string): void;
    close(): void;
}
 
// ============================================
// Abstract Base Class: The Template
// ============================================
 
abstract class DocumentExporter {
    private eventBus: EventBus;
    
    constructor(eventBus: EventBus) {
        this.eventBus = eventBus;
    }
    
    /**
     * THE TEMPLATE METHOD
     * 
     * Defines the skeleton of the export algorithm.
     * This method should NOT be overridden by subclasses.
     * 
     * In languages with 'final', this would be marked final.
     * In TypeScript, we rely on convention and documentation.
     */
    public export(source: DataSource, baseFilename: string): void {
        // HOOK: Allow pre-export customization
        this.beforeExport();
        
        // CONCRETE: Gather and enrich data (shared logic)
        const data = this.gatherData(source);
        
        // HOOK: Allow custom validation
        if (!this.validateData(data)) {
            this.handleValidationFailure(data);
            return;
        }
        
        // CONCRETE: Prepare output stream
        const filename = `${baseFilename}.${this.getFileExtension()}`;
        const stream = this.openOutputStream(filename);
        
        try {
            // ABSTRACT: Write format-specific header
            this.writeHeader(stream);
            
            // HOOK: Optional metadata injection
            const metadata = this.getMetadata();
            if (Object.keys(metadata).length > 0) {
                this.writeMetadata(stream, metadata);
            }
            
            // ABSTRACT: Write format-specific body
            this.writeBody(stream, data);
            
            // ABSTRACT: Write format-specific footer
            this.writeFooter(stream);
            
        } finally {
            // CONCRETE: Always close the stream
            stream.close();
        }
        
        // HOOK: Allow post-export customization
        this.afterExport(filename);
        
        // CONCRETE: Notify completion
        this.notifyCompletion(filename);
    }
    
    // ============================================
    // CONCRETE OPERATIONS (Invariant Behavior)
    // ============================================
    
    protected gatherData(source: DataSource): EnrichedData {
        console.log("Gathering data from source...");
        const rawData = source.fetchAll();
        
        const records = rawData.items.map(item => ({
            ...item,
            processed: true
        }));
        
        console.log(`Gathered ${records.length} records`);
        
        return {
            records,
            metadata: {
                exportedAt: new Date().toISOString(),
                recordCount: String(records.length)
            }
        };
    }
    
    protected openOutputStream(filename: string): OutputStream {
        console.log(`Opening output stream: ${filename}`);
        return new FileOutputStream(filename);
    }
    
    protected notifyCompletion(filename: string): void {
        console.log(`Export completed: ${filename}`);
        this.eventBus.emit('export:complete', { filename });
    }
    
    protected handleValidationFailure(data: EnrichedData): void {
        console.error("Validation failed, export aborted");
        this.eventBus.emit('export:failed', { reason: 'validation' });
    }
    
    // ============================================
    // ABSTRACT OPERATIONS (Required Variation)
    // ============================================
    
    /** Returns the file extension for this format (e.g., "pdf", "html") */
    protected abstract getFileExtension(): string;
    
    /** Writes the format-specific header to the stream */
    protected abstract writeHeader(stream: OutputStream): void;
    
    /** Writes the main content in the format-specific structure */
    protected abstract writeBody(stream: OutputStream, data: EnrichedData): void;
    
    /** Writes the format-specific footer/closing to the stream */
    protected abstract writeFooter(stream: OutputStream): void;
    
    // ============================================
    // HOOK OPERATIONS (Optional Customization)
    // ============================================
    
    /** Hook: Called before export starts. Override for pre-processing. */
    protected beforeExport(): void {
        // Default: do nothing
    }
    
    /** Hook: Called after export completes. Override for post-processing. */
    protected afterExport(filename: string): void {
        // Default: do nothing
    }
    
    /** Hook: Validates data before export. Return false to abort. */
    protected validateData(data: EnrichedData): boolean {
        return true;  // Default: all data is valid
    }
    
    /** Hook: Returns additional metadata to inject. */
    protected getMetadata(): Record<string, string> {
        return {};  // Default: no extra metadata
    }
    
    /** Hook: Writes metadata to the stream (format-specific). */
    protected writeMetadata(stream: OutputStream, metadata: Record<string, string>): void {
        // Default: do nothing (subclasses override if they support metadata)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// ============================================
// CONCRETE CLASSES: Format-Specific Exporters
// ============================================
 
class PdfExporter extends DocumentExporter {
    protected getFileExtension(): string {
        return "pdf";
    }
    
    protected writeHeader(stream: OutputStream): void {
        stream.write("%PDF-1.7\n");
        stream.write("%\xE2\xE3\xCF\xD3\n");
        stream.write("1 0 obj\n");
        stream.write("<< /Type /Catalog /Pages 2 0 R >>\n");
        stream.write("endobj\n");
    }
    
    protected writeBody(stream: OutputStream, data: EnrichedData): void {
        // Simplified PDF body generation
        let yPosition = 750;
        const pageContent: string[] = [];
        
        for (const record of data.records) {
            pageContent.push(`BT /F1 12 Tf 50 ${yPosition} Td (${record.content}) Tj ET`);
            yPosition -= 20;
        }
        
        stream.write("2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n");
        stream.write(`3 0 obj << /Type /Page /Contents 4 0 R >> endobj\n`);
        stream.write(`4 0 obj << /Length ${pageContent.join(' ').length} >>\n`);
        stream.write("stream\n");
        stream.write(pageContent.join(' '));
        stream.write("\nendstream\nendobj\n");
    }
    
    protected writeFooter(stream: OutputStream): void {
        stream.write("xref\n");
        stream.write("0 5\n");
        stream.write("trailer << /Size 5 /Root 1 0 R >>\n");
        stream.write("startxref\n");
        stream.write("%%EOF\n");
    }
}
 
class HtmlExporter extends DocumentExporter {
    private cssStyles: string = '';
    
    constructor(eventBus: EventBus, cssStyles?: string) {
        super(eventBus);
        this.cssStyles = cssStyles || this.getDefaultStyles();
    }
    
    protected getFileExtension(): string {
        return "html";
    }
    
    protected writeHeader(stream: OutputStream): void {
        stream.write("<!DOCTYPE html>\n");
        stream.write("<html lang=\"en\">\n");
        stream.write("<head>\n");
        stream.write("  <meta charset=\"UTF-8\">\n");
        stream.write("  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n");
        stream.write("  <title>Exported Report</title>\n");
        stream.write(`  <style>${this.cssStyles}</style>\n`);
        stream.write("</head>\n");
        stream.write("<body>\n");
        stream.write("  <main class=\"report-container\">\n");
    }
    
    protected writeBody(stream: OutputStream, data: EnrichedData): void {
        stream.write("    <section class=\"records\">\n");
        
        for (const record of data.records) {
            stream.write(`      <article class="record" id="record-${record.id}">\n`);
            stream.write(`        <h2>${this.escapeHtml(record.id)}</h2>\n`);
            stream.write(`        <p>${this.escapeHtml(record.content)}</p>\n`);
            stream.write("      </article>\n");
        }
        
        stream.write("    </section>\n");
    }
    
    protected writeFooter(stream: OutputStream): void {
        stream.write("  </main>\n");
        stream.write("</body>\n");
        stream.write("</html>\n");
    }
    
    // Override hook to inject metadata as meta tags
    protected writeMetadata(stream: OutputStream, metadata: Record<string, string>): void {
        for (const [key, value] of Object.entries(metadata)) {
            stream.write(`    <meta name="${key}" content="${value}">\n`);
        }
    }
    
    private escapeHtml(text: string): string {
        return text
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;');
    }
    
    private getDefaultStyles(): string {
        return `
            body { font-family: system-ui, sans-serif; }
            .report-container { max-width: 800px; margin: 0 auto; }
            .record { padding: 1rem; border-bottom: 1px solid #eee; }
        `;
    }
}
 
class CsvExporter extends DocumentExporter {
    private delimiter: string = ',';
    
    constructor(eventBus: EventBus, delimiter?: string) {
        super(eventBus);
        this.delimiter = delimiter || ',';
    }
    
    protected getFileExtension(): string {
        return "csv";
    }
    
    protected writeHeader(stream: OutputStream): void {
        // CSV header row
        stream.write(`ID${this.delimiter}Content${this.delimiter}Processed\n`);
    }
    
    protected writeBody(stream: OutputStream, data: EnrichedData): void {
        for (const record of data.records) {
            const escapedContent = this.escapeCsv(record.content);
            stream.write(`${record.id}${this.delimiter}${escapedContent}${this.delimiter}${record.processed}\n`);
        }
    }
    
    protected writeFooter(stream: OutputStream): void {
        // CSV has no footer
    }
    
    // Override hook to add validation
    protected validateData(data: EnrichedData): boolean {
        // Ensure no record contains the delimiter in unsafe way
        for (const record of data.records) {
            if (record.id.includes(this.delimiter)) {
                console.error(`Record ID contains delimiter: ${record.id}`);
                return false;
            }
        }
        return true;
    }
    
    private escapeCsv(text: string): string {
        if (text.includes(this.delimiter) || text.includes('"') || text.includes('\n')) {
            return '"' + text.replace(/"/g, '""') + '"';
        }
        return text;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Client code — completely decoupled from export specifics
function exportReport(source: DataSource, format: 'pdf' | 'html' | 'csv'): void {
    const eventBus = new EventBus();
    let exporter: DocumentExporter;
    
    switch (format) {
        case 'pdf':
            exporter = new PdfExporter(eventBus);
            break;
        case 'html':
            exporter = new HtmlExporter(eventBus);
            break;
        case 'csv':
            exporter = new CsvExporter(eventBus);
            break;
    }
    
    // The template method is called — algorithm executes
    exporter.export(source, 'quarterly_report');
}
 
// Adding a new format is simple:
// 1. Create new class extending DocumentExporter
// 2. Implement the 4 abstract methods
// 3. Optionally override hooks for custom behavior
// 4. NO changes to DocumentExporter or existing exporters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

abstract class DocumentExporter {
    // The sequence is locked in the template method
    public export(source: DataSource, filename: string): void {
        this.beforeExport();         // 1. Always first
        const data = this.gatherData(source);  // 2. Always second
        this.validateData(data);     // 3. Always third
        this.writeHeader(stream);    // 4. Always fourth
        this.writeBody(stream, data);// 5. Always fifth
        this.writeFooter(stream);    // 6. Always sixth
        this.afterExport(filename);  // 7. Always seventh
        this.notifyCompletion(filename); // 8. Always last
    }
}
 
// A subclass CANNOT do this:
class BadExporter extends DocumentExporter {
    // ERROR: Cannot reorder the algorithm
    // The subclass only provides implementations for abstract methods
    // It does not control when those methods are called
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// This would cause a compile-time error:
class IncompleteExporter extends DocumentExporter {
    protected getFileExtension(): string {
        return "txt";
    }
    
    protected writeHeader(stream: OutputStream): void {
        stream.write("header\n");
    }
    
    // ERROR: Class 'IncompleteExporter' is not abstract and does not implement
    // inherited abstract member 'writeBody' from class 'DocumentExporter'.
    
    // ERROR: Class 'IncompleteExporter' is not abstract and does not implement
    // inherited abstract member 'writeFooter' from class 'DocumentExporter'.
}
 
// You MUST implement all abstract methods to create a concrete class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

abstract class DocumentExporter {
    // In Java, this would be: public final void export(...)
    // The 'final' keyword prevents subclass override
    
    // In TypeScript, we use documentation and code review
    /**
     * THE TEMPLATE METHOD - DO NOT OVERRIDE
     * 
     * This method defines the export algorithm. Subclasses should implement
     * the abstract methods (writeHeader, writeBody, writeFooter, getFileExtension)
     * rather than overriding this method.
     */
    public export(source: DataSource, filename: string): void {
        // ... algorithm ...
    }
    
    // Critical shared logic can be made private
    // Private methods cannot be overridden
    private closeStreamSafely(stream: OutputStream): void {
        try {
            stream.flush();
            stream.close();
        } catch (error) {
            console.error("Failed to close stream:", error);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

┌─────────────────────────────────────────────────────────────┐
│                      AbstractClass                          │
├─────────────────────────────────────────────────────────────┤
│ + templateMethod(): void  ←── Defines algorithm skeleton     │
│ # primitiveOperation1(): void  ←── Abstract (must implement) │
│ # primitiveOperation2(): void  ←── Abstract (must implement) │
│ # hook(): void  ←── Optional override (has default impl)    │
│ # concreteOperation(): void  ←── Shared, invariant logic    │
└─────────────────────────────────────────────────────────────┘
                              △
                              │ extends
          ┌───────────────────┴───────────────────┐
          │                                       │
┌─────────────────────────┐         ┌─────────────────────────┐
│    ConcreteClassA       │         │    ConcreteClassB       │
├─────────────────────────┤         ├─────────────────────────┤
│ # primitiveOperation1() │         │ # primitiveOperation1() │
│ # primitiveOperation2() │         │ # primitiveOperation2() │
│ # hook()  ←── optional  │         │                         │
└─────────────────────────┘         └─────────────────────────┘
 
Template Method Call Flow:
─────────────────────────
 
Client calls:  abstractClass.templateMethod()
                    │
                    ▼
    ┌───────────────────────────────────────┐
    │  templateMethod() executes:           │
    │  ┌─────────────────────────────────┐ │
    │  │ this.concreteOperation()        │──┼─→ Calls base class method
    │  │ this.primitiveOperation1()      │──┼─→ Calls subclass override
    │  │ this.hook()                     │──┼─→ Calls override or default
    │  │ this.primitiveOperation2()      │──┼─→ Calls subclass override
    │  └─────────────────────────────────┘ │
    └───────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

abstract class DocumentExporter {
    // Hook with meaningful default behavior
    protected afterExport(filename: string): void {
        // Default: log completion
        console.log(`Finished exporting: ${filename}`);
    }
}
 
class AuditingPdfExporter extends PdfExporter {
    // CORRECT: Extend the hook, don't replace it
    protected afterExport(filename: string): void {
        // Call parent's default behavior
        super.afterExport(filename);
        
        // Add custom behavior
        this.auditLog.record({
            action: 'export',
            file: filename,
            timestamp: new Date(),
            user: this.currentUser
        });
    }
}
 
class SilentPdfExporter extends PdfExporter {
    // Also valid: Replace the hook entirely if desired
    protected afterExport(filename: string): void {
        // Intentionally empty — suppress all output
    }
}