Visitor Pattern: Adding Operations Without Modifying Classes

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

// ═══════════════════════════════════════════════════════════════
// EXPRESSION LANGUAGE: A Complete Multi-Visitor Example
// ═══════════════════════════════════════════════════════════════
 
// ─── Type System ───────────────────────────────────────────────
 
type ExprType = 'number' | 'boolean' | 'string' | 'error';
 
class TypeError {
    constructor(
        public message: string,
        public location: string
    ) {}
}
 
// ─── Visitor Interface ─────────────────────────────────────────
 
interface ExpressionVisitor<R> {
    visitNumberLiteral(expr: NumberLiteral): R;
    visitStringLiteral(expr: StringLiteral): R;
    visitBooleanLiteral(expr: BooleanLiteral): R;
    visitBinaryOp(expr: BinaryOp): R;
    visitUnaryOp(expr: UnaryOp): R;
    visitVariable(expr: Variable): R;
    visitConditional(expr: Conditional): R;
    visitFunctionCall(expr: FunctionCall): R;
}
 
// ─── Expression Base and Concrete Types ────────────────────────
 
abstract class Expression {
    abstract accept<R>(visitor: ExpressionVisitor<R>): R;
    abstract toString(): string;
}
 
class NumberLiteral extends Expression {
    constructor(public readonly value: number) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitNumberLiteral(this);
    }
    
    toString(): string { return this.value.toString(); }
}
 
class StringLiteral extends Expression {
    constructor(public readonly value: string) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitStringLiteral(this);
    }
    
    toString(): string { return `"${this.value}"`; }
}
 
class BooleanLiteral extends Expression {
    constructor(public readonly value: boolean) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitBooleanLiteral(this);
    }
    
    toString(): string { return this.value.toString(); }
}
 
class BinaryOp extends Expression {
    constructor(
        public readonly left: Expression,
        public readonly operator: '+' | '-' | '*' | '/' | '==' | '!=' | '<' | '>' | '&&' | '||',
        public readonly right: Expression
    ) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitBinaryOp(this);
    }
    
    toString(): string { 
        return `(${this.left} ${this.operator} ${this.right})`; 
    }
}
 
class UnaryOp extends Expression {
    constructor(
        public readonly operator: '-' | '!',
        public readonly operand: Expression
    ) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitUnaryOp(this);
    }
    
    toString(): string { return `(${this.operator}${this.operand})`; }
}
 
class Variable extends Expression {
    constructor(public readonly name: string) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitVariable(this);
    }
    
    toString(): string { return this.name; }
}
 
class Conditional extends Expression {
    constructor(
        public readonly condition: Expression,
        public readonly thenBranch: Expression,
        public readonly elseBranch: Expression
    ) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitConditional(this);
    }
    
    toString(): string { 
        return `(${this.condition} ? ${this.thenBranch} : ${this.elseBranch})`; 
    }
}
 
class FunctionCall extends Expression {
    constructor(
        public readonly name: string,
        public readonly args: Expression[]
    ) { super(); }
    
    accept<R>(visitor: ExpressionVisitor<R>): R {
        return visitor.visitFunctionCall(this);
    }
    
    toString(): string { 
        return `${this.name}(${this.args.join(', ')})`; 
    }
}

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
173
174
175
176
177
178
179
180

// ─── Type Checker Visitor ──────────────────────────────────────
 
interface TypeEnvironment {
    variables: Map<string, ExprType>;
    functions: Map<string, { params: ExprType[]; returnType: ExprType }>;
}
 
class TypeCheckVisitor implements ExpressionVisitor<ExprType> {
    private errors: TypeError[] = [];
    
    constructor(private env: TypeEnvironment) {}
    
    visitNumberLiteral(expr: NumberLiteral): ExprType {
        return 'number';
    }
    
    visitStringLiteral(expr: StringLiteral): ExprType {
        return 'string';
    }
    
    visitBooleanLiteral(expr: BooleanLiteral): ExprType {
        return 'boolean';
    }
    
    visitBinaryOp(expr: BinaryOp): ExprType {
        const leftType = expr.left.accept(this);
        const rightType = expr.right.accept(this);
        
        // Arithmetic operators require numbers
        if (['+', '-', '*', '/'].includes(expr.operator)) {
            if (expr.operator === '+' && leftType === 'string' && rightType === 'string') {
                return 'string';  // String concatenation
            }
            if (leftType !== 'number' || rightType !== 'number') {
                this.errors.push(new TypeError(
                    `Operator '${expr.operator}' requires number operands, got ${leftType} and ${rightType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'number';
        }
        
        // Comparison operators
        if (['<', '>'].includes(expr.operator)) {
            if (leftType !== 'number' || rightType !== 'number') {
                this.errors.push(new TypeError(
                    `Comparison requires numbers, got ${leftType} and ${rightType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'boolean';
        }
        
        // Equality operators work on any same type
        if (['==', '!='].includes(expr.operator)) {
            if (leftType !== rightType) {
                this.errors.push(new TypeError(
                    `Cannot compare ${leftType} with ${rightType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'boolean';
        }
        
        // Logical operators require booleans
        if (['&&', '||'].includes(expr.operator)) {
            if (leftType !== 'boolean' || rightType !== 'boolean') {
                this.errors.push(new TypeError(
                    `Logical operator requires booleans, got ${leftType} and ${rightType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'boolean';
        }
        
        return 'error';
    }
    
    visitUnaryOp(expr: UnaryOp): ExprType {
        const operandType = expr.operand.accept(this);
        
        if (expr.operator === '-') {
            if (operandType !== 'number') {
                this.errors.push(new TypeError(
                    `Unary minus requires number, got ${operandType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'number';
        }
        
        if (expr.operator === '!') {
            if (operandType !== 'boolean') {
                this.errors.push(new TypeError(
                    `Logical not requires boolean, got ${operandType}`,
                    expr.toString()
                ));
                return 'error';
            }
            return 'boolean';
        }
        
        return 'error';
    }
    
    visitVariable(expr: Variable): ExprType {
        const type = this.env.variables.get(expr.name);
        if (!type) {
            this.errors.push(new TypeError(
                `Undefined variable: ${expr.name}`,
                expr.toString()
            ));
            return 'error';
        }
        return type;
    }
    
    visitConditional(expr: Conditional): ExprType {
        const condType = expr.condition.accept(this);
        const thenType = expr.thenBranch.accept(this);
        const elseType = expr.elseBranch.accept(this);
        
        if (condType !== 'boolean') {
            this.errors.push(new TypeError(
                `Condition must be boolean, got ${condType}`,
                expr.toString()
            ));
        }
        
        if (thenType !== elseType) {
            this.errors.push(new TypeError(
                `Conditional branches must have same type: ${thenType} vs ${elseType}`,
                expr.toString()
            ));
            return 'error';
        }
        
        return thenType;
    }
    
    visitFunctionCall(expr: FunctionCall): ExprType {
        const func = this.env.functions.get(expr.name);
        if (!func) {
            this.errors.push(new TypeError(
                `Undefined function: ${expr.name}`,
                expr.toString()
            ));
            return 'error';
        }
        
        if (expr.args.length !== func.params.length) {
            this.errors.push(new TypeError(
                `Function ${expr.name} expects ${func.params.length} args, got ${expr.args.length}`,
                expr.toString()
            ));
            return 'error';
        }
        
        for (let i = 0; i < expr.args.length; i++) {
            const argType = expr.args[i].accept(this);
            if (argType !== func.params[i]) {
                this.errors.push(new TypeError(
                    `Argument ${i + 1} of ${expr.name}: expected ${func.params[i]}, got ${argType}`,
                    expr.args[i].toString()
                ));
            }
        }
        
        return func.returnType;
    }
    
    getErrors(): TypeError[] {
        return this.errors;
    }
}

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

// ─── Constant Folding Optimizer ────────────────────────────────
 
class ConstantFoldVisitor implements ExpressionVisitor<Expression> {
    visitNumberLiteral(expr: NumberLiteral): Expression {
        return expr;  // Already a constant
    }
    
    visitStringLiteral(expr: StringLiteral): Expression {
        return expr;  // Already a constant
    }
    
    visitBooleanLiteral(expr: BooleanLiteral): Expression {
        return expr;  // Already a constant
    }
    
    visitBinaryOp(expr: BinaryOp): Expression {
        // First, recursively optimize children
        const left = expr.left.accept(this);
        const right = expr.right.accept(this);
        
        // If both are number literals, fold
        if (left instanceof NumberLiteral && right instanceof NumberLiteral) {
            switch (expr.operator) {
                case '+': return new NumberLiteral(left.value + right.value);
                case '-': return new NumberLiteral(left.value - right.value);
                case '*': return new NumberLiteral(left.value * right.value);
                case '/': return new NumberLiteral(left.value / right.value);
                case '<': return new BooleanLiteral(left.value < right.value);
                case '>': return new BooleanLiteral(left.value > right.value);
                case '==': return new BooleanLiteral(left.value === right.value);
                case '!=': return new BooleanLiteral(left.value !== right.value);
            }
        }
        
        // If both are string literals with +, concatenate
        if (left instanceof StringLiteral && right instanceof StringLiteral) {
            if (expr.operator === '+') {
                return new StringLiteral(left.value + right.value);
            }
        }
        
        // If both are boolean literals
        if (left instanceof BooleanLiteral && right instanceof BooleanLiteral) {
            switch (expr.operator) {
                case '&&': return new BooleanLiteral(left.value && right.value);
                case '||': return new BooleanLiteral(left.value || right.value);
                case '==': return new BooleanLiteral(left.value === right.value);
                case '!=': return new BooleanLiteral(left.value !== right.value);
            }
        }
        
        // Algebraic simplifications
        if (left instanceof NumberLiteral) {
            if (left.value === 0 && expr.operator === '+') return right;  // 0 + x = x
            if (left.value === 1 && expr.operator === '*') return right;  // 1 * x = x
            if (left.value === 0 && expr.operator === '*') return new NumberLiteral(0);
        }
        
        if (right instanceof NumberLiteral) {
            if (right.value === 0 && expr.operator === '+') return left;   // x + 0 = x
            if (right.value === 0 && expr.operator === '-') return left;   // x - 0 = x
            if (right.value === 1 && expr.operator === '*') return left;   // x * 1 = x
            if (right.value === 0 && expr.operator === '*') return new NumberLiteral(0);
        }
        
        // Boolean short-circuit simplifications
        if (left instanceof BooleanLiteral) {
            if (!left.value && expr.operator === '&&') return new BooleanLiteral(false);
            if (left.value && expr.operator === '||') return new BooleanLiteral(true);
        }
        
        // Can't fold; return rebuilt expression with optimized children
        return new BinaryOp(left, expr.operator, right);
    }
    
    visitUnaryOp(expr: UnaryOp): Expression {
        const operand = expr.operand.accept(this);
        
        if (operand instanceof NumberLiteral && expr.operator === '-') {
            return new NumberLiteral(-operand.value);
        }
        
        if (operand instanceof BooleanLiteral && expr.operator === '!') {
            return new BooleanLiteral(!operand.value);
        }
        
        // Double negation elimination
        if (expr.operator === '-' && operand instanceof UnaryOp && operand.operator === '-') {
            return operand.operand;  // --x = x
        }
        
        if (expr.operator === '!' && operand instanceof UnaryOp && operand.operator === '!') {
            return operand.operand;  // !!x = x
        }
        
        return new UnaryOp(expr.operator, operand);
    }
    
    visitVariable(expr: Variable): Expression {
        return expr;  // Variables can't be folded (without data flow analysis)
    }
    
    visitConditional(expr: Conditional): Expression {
        const condition = expr.condition.accept(this);
        const thenBranch = expr.thenBranch.accept(this);
        const elseBranch = expr.elseBranch.accept(this);
        
        // If condition is constant, eliminate dead branch
        if (condition instanceof BooleanLiteral) {
            return condition.value ? thenBranch : elseBranch;
        }
        
        return new Conditional(condition, thenBranch, elseBranch);
    }
    
    visitFunctionCall(expr: FunctionCall): Expression {
        // Optimize arguments
        const optimizedArgs = expr.args.map(arg => arg.accept(this));
        
        // Could fold pure functions with constant args (e.g., sqrt(4) -> 2)
        // Omitted for brevity
        
        return new FunctionCall(expr.name, optimizedArgs);
    }
}

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

// ─── JavaScript Code Generator ─────────────────────────────────
 
class JavaScriptEmitVisitor implements ExpressionVisitor<string> {
    visitNumberLiteral(expr: NumberLiteral): string {
        return expr.value.toString();
    }
    
    visitStringLiteral(expr: StringLiteral): string {
        return JSON.stringify(expr.value);  // Handles escaping
    }
    
    visitBooleanLiteral(expr: BooleanLiteral): string {
        return expr.value.toString();
    }
    
    visitBinaryOp(expr: BinaryOp): string {
        const left = expr.left.accept(this);
        const right = expr.right.accept(this);
        return `(${left} ${expr.operator} ${right})`;
    }
    
    visitUnaryOp(expr: UnaryOp): string {
        const operand = expr.operand.accept(this);
        return `(${expr.operator}${operand})`;
    }
    
    visitVariable(expr: Variable): string {
        return expr.name;
    }
    
    visitConditional(expr: Conditional): string {
        const cond = expr.condition.accept(this);
        const thenBranch = expr.thenBranch.accept(this);
        const elseBranch = expr.elseBranch.accept(this);
        return `(${cond} ? ${thenBranch} : ${elseBranch})`;
    }
    
    visitFunctionCall(expr: FunctionCall): string {
        const args = expr.args.map(arg => arg.accept(this));
        
        // Map to JavaScript equivalents
        const funcMap: Record<string, string> = {
            'sqrt': 'Math.sqrt',
            'abs': 'Math.abs',
            'sin': 'Math.sin',
            'cos': 'Math.cos',
            'floor': 'Math.floor',
            'ceil': 'Math.ceil',
        };
        
        const jsFunc = funcMap[expr.name] || expr.name;
        return `${jsFunc}(${args.join(', ')})`;
    }
}
 
// ─── Usage Example ─────────────────────────────────────────────
 
// Expression: (x + 2) * 3 + sqrt(y)
const expr = new BinaryOp(
    new BinaryOp(
        new BinaryOp(new Variable('x'), '+', new NumberLiteral(2)),
        '*',
        new NumberLiteral(3)
    ),
    '+',
    new FunctionCall('sqrt', [new Variable('y')])
);
 
// Type check
const env: TypeEnvironment = {
    variables: new Map([['x', 'number'], ['y', 'number']]),
    functions: new Map([['sqrt', { params: ['number'], returnType: 'number' }]])
};
const typeChecker = new TypeCheckVisitor(env);
const exprType = expr.accept(typeChecker);
console.log(`Type: ${exprType}`);  // Type: number
console.log(`Errors: ${typeChecker.getErrors().length}`);  // Errors: 0
 
// Now with a constant: (5 + 2) * 3 + sqrt(16)
const constExpr = new BinaryOp(
    new BinaryOp(
        new BinaryOp(new NumberLiteral(5), '+', new NumberLiteral(2)),
        '*',
        new NumberLiteral(3)
    ),
    '+',
    new FunctionCall('sqrt', [new NumberLiteral(16)])
);
 
// Optimize
const optimizer = new ConstantFoldVisitor();
const optimized = constExpr.accept(optimizer);
console.log(`Before: ${constExpr}`);    // ((5 + 2) * 3) + sqrt(16))
console.log(`After: ${optimized}`);      // (21 + sqrt(16))  - partially folded
 
// Generate JavaScript
const emitter = new JavaScriptEmitVisitor();
console.log(`JS: ${expr.accept(emitter)}`);  
// JS: (((x + 2) * 3) + Math.sqrt(y))

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

// ═══════════════════════════════════════════════════════════════
// DOCUMENT PROCESSING SYSTEM
// Demonstrates: Composite structure, multiple export formats
// ═══════════════════════════════════════════════════════════════
 
// ─── Visitor Interface ─────────────────────────────────────────
 
interface DocumentVisitor<R> {
    visitDocument(doc: Document): R;
    visitSection(section: Section): R;
    visitParagraph(para: Paragraph): R;
    visitHeading(heading: Heading): R;
    visitList(list: List): R;
    visitListItem(item: ListItem): R;
    visitCodeBlock(code: CodeBlock): R;
    visitImage(image: Image): R;
    visitLink(link: Link): R;
    visitEmphasis(emphasis: Emphasis): R;
}
 
// ─── Document Elements ─────────────────────────────────────────
 
interface DocumentElement {
    accept<R>(visitor: DocumentVisitor<R>): R;
}
 
class Document implements DocumentElement {
    constructor(
        public readonly title: string,
        public readonly sections: Section[]
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitDocument(this);
    }
}
 
class Section implements DocumentElement {
    constructor(
        public readonly id: string,
        public readonly content: DocumentElement[]
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitSection(this);
    }
}
 
class Paragraph implements DocumentElement {
    constructor(public readonly content: (string | DocumentElement)[]) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitParagraph(this);
    }
}
 
class Heading implements DocumentElement {
    constructor(
        public readonly level: 1 | 2 | 3 | 4 | 5 | 6,
        public readonly text: string
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitHeading(this);
    }
}
 
class List implements DocumentElement {
    constructor(
        public readonly ordered: boolean,
        public readonly items: ListItem[]
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitList(this);
    }
}
 
class ListItem implements DocumentElement {
    constructor(public readonly content: DocumentElement[]) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitListItem(this);
    }
}
 
class CodeBlock implements DocumentElement {
    constructor(
        public readonly language: string,
        public readonly code: string
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitCodeBlock(this);
    }
}
 
class Image implements DocumentElement {
    constructor(
        public readonly src: string,
        public readonly alt: string,
        public readonly caption?: string
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitImage(this);
    }
}
 
class Link implements DocumentElement {
    constructor(
        public readonly href: string,
        public readonly text: string
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitLink(this);
    }
}
 
class Emphasis implements DocumentElement {
    constructor(
        public readonly type: 'bold' | 'italic' | 'code',
        public readonly text: string
    ) {}
    
    accept<R>(visitor: DocumentVisitor<R>): R {
        return visitor.visitEmphasis(this);
    }
}

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

// ─── HTML Export Visitor ───────────────────────────────────────
 
class HtmlExportVisitor implements DocumentVisitor<string> {
    private indent = 0;
    
    private getIndent(): string {
        return '  '.repeat(this.indent);
    }
    
    visitDocument(doc: Document): string {
        const sections = doc.sections.map(s => s.accept(this)).join('\n');
        return `<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>${this.escapeHtml(doc.title)}</title>
    <style>
        body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; }
        pre { background: #f4f4f4; padding: 1rem; border-radius: 4px; overflow-x: auto; }
        code { font-family: 'Fira Code', monospace; }
        img { max-width: 100%; height: auto; }
        figcaption { text-align: center; font-style: italic; color: #666; }
    </style>
</head>
<body>
    <h1>${this.escapeHtml(doc.title)}</h1>
${sections}
</body>
</html>`;
    }
    
    visitSection(section: Section): string {
        this.indent++;
        const content = section.content.map(el => el.accept(this)).join('\n');
        this.indent--;
        return `${this.getIndent()}<section id="${section.id}">\n${content}\n${this.getIndent()}</section>`;
    }
    
    visitParagraph(para: Paragraph): string {
        const content = para.content.map(c => 
            typeof c === 'string' ? this.escapeHtml(c) : c.accept(this)
        ).join('');
        return `${this.getIndent()}<p>${content}</p>`;
    }
    
    visitHeading(heading: Heading): string {
        const tag = `h${heading.level}`;
        return `${this.getIndent()}<${tag}>${this.escapeHtml(heading.text)}</${tag}>`;
    }
    
    visitList(list: List): string {
        const tag = list.ordered ? 'ol' : 'ul';
        this.indent++;
        const items = list.items.map(item => item.accept(this)).join('\n');
        this.indent--;
        return `${this.getIndent()}<${tag}>\n${items}\n${this.getIndent()}</${tag}>`;
    }
    
    visitListItem(item: ListItem): string {
        const content = item.content.map(el => el.accept(this)).join('');
        return `${this.getIndent()}<li>${content}</li>`;
    }
    
    visitCodeBlock(code: CodeBlock): string {
        return `${this.getIndent()}<pre><code class="language-${code.language}">${this.escapeHtml(code.code)}</code></pre>`;
    }
    
    visitImage(image: Image): string {
        const img = `<img src="${image.src}" alt="${this.escapeHtml(image.alt)}" />`;
        if (image.caption) {
            return `${this.getIndent()}<figure>\n${this.getIndent()}  ${img}\n${this.getIndent()}  <figcaption>${this.escapeHtml(image.caption)}</figcaption>\n${this.getIndent()}</figure>`;
        }
        return `${this.getIndent()}${img}`;
    }
    
    visitLink(link: Link): string {
        return `<a href="${link.href}">${this.escapeHtml(link.text)}</a>`;
    }
    
    visitEmphasis(emphasis: Emphasis): string {
        switch (emphasis.type) {
            case 'bold': return `<strong>${this.escapeHtml(emphasis.text)}</strong>`;
            case 'italic': return `<em>${this.escapeHtml(emphasis.text)}</em>`;
            case 'code': return `<code>${this.escapeHtml(emphasis.text)}</code>`;
        }
    }
    
    private escapeHtml(text: string): string {
        return text
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;');
    }
}

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

// ─── Markdown Export Visitor ───────────────────────────────────
 
class MarkdownExportVisitor implements DocumentVisitor<string> {
    visitDocument(doc: Document): string {
        const sections = doc.sections.map(s => s.accept(this)).join('\n\n');
        return `# ${doc.title}\n\n${sections}`;
    }
    
    visitSection(section: Section): string {
        return section.content.map(el => el.accept(this)).join('\n\n');
    }
    
    visitParagraph(para: Paragraph): string {
        return para.content.map(c => 
            typeof c === 'string' ? c : c.accept(this)
        ).join('');
    }
    
    visitHeading(heading: Heading): string {
        const prefix = '#'.repeat(heading.level);
        return `${prefix} ${heading.text}`;
    }
    
    visitList(list: List): string {
        return list.items.map((item, index) => {
            const prefix = list.ordered ? `${index + 1}.` : '-';
            const content = item.accept(this);
            return `${prefix} ${content}`;
        }).join('\n');
    }
    
    visitListItem(item: ListItem): string {
        return item.content.map(el => el.accept(this)).join('');
    }
    
    visitCodeBlock(code: CodeBlock): string {
        return `\`\`\`${code.language}\n${code.code}\n\`\`\``;
    }
    
    visitImage(image: Image): string {
        const md = `![${image.alt}](${image.src})`;
        return image.caption ? `${md}\n\n*${image.caption}*` : md;
    }
    
    visitLink(link: Link): string {
        return `[${link.text}](${link.href})`;
    }
    
    visitEmphasis(emphasis: Emphasis): string {
        switch (emphasis.type) {
            case 'bold': return `**${emphasis.text}**`;
            case 'italic': return `*${emphasis.text}*`;
            case 'code': return `\`${emphasis.text}\``;
        }
    }
}
 
// ─── Statistics Visitor ────────────────────────────────────────
 
interface DocumentStats {
    wordCount: number;
    headingCount: number;
    imageCount: number;
    linkCount: number;
    codeBlockCount: number;
    sectionCount: number;
}
 
class StatisticsVisitor implements DocumentVisitor<void> {
    private stats: DocumentStats = {
        wordCount: 0,
        headingCount: 0,
        imageCount: 0,
        linkCount: 0,
        codeBlockCount: 0,
        sectionCount: 0
    };
    
    getStats(): DocumentStats {
        return { ...this.stats };
    }
    
    private countWords(text: string): number {
        return text.trim().split(/\s+/).filter(w => w.length > 0).length;
    }
    
    visitDocument(doc: Document): void {
        this.stats.wordCount += this.countWords(doc.title);
        doc.sections.forEach(s => s.accept(this));
    }
    
    visitSection(section: Section): void {
        this.stats.sectionCount++;
        section.content.forEach(el => el.accept(this));
    }
    
    visitParagraph(para: Paragraph): void {
        para.content.forEach(c => {
            if (typeof c === 'string') {
                this.stats.wordCount += this.countWords(c);
            } else {
                c.accept(this);
            }
        });
    }
    
    visitHeading(heading: Heading): void {
        this.stats.headingCount++;
        this.stats.wordCount += this.countWords(heading.text);
    }
    
    visitList(list: List): void {
        list.items.forEach(item => item.accept(this));
    }
    
    visitListItem(item: ListItem): void {
        item.content.forEach(el => el.accept(this));
    }
    
    visitCodeBlock(code: CodeBlock): void {
        this.stats.codeBlockCount++;
        // Don't count code lines as words
    }
    
    visitImage(image: Image): void {
        this.stats.imageCount++;
        this.stats.wordCount += this.countWords(image.alt);
        if (image.caption) {
            this.stats.wordCount += this.countWords(image.caption);
        }
    }
    
    visitLink(link: Link): void {
        this.stats.linkCount++;
        this.stats.wordCount += this.countWords(link.text);
    }
    
    visitEmphasis(emphasis: Emphasis): void {
        this.stats.wordCount += this.countWords(emphasis.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
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239

// ═══════════════════════════════════════════════════════════════
// FILE SYSTEM VISITOR EXAMPLE
// Demonstrates: Size calculation, search, permission check
// ═══════════════════════════════════════════════════════════════
 
// ─── Visitor Interface ─────────────────────────────────────────
 
interface FileSystemVisitor<R> {
    visitFile(file: File): R;
    visitDirectory(dir: Directory): R;
    visitSymlink(link: Symlink): R;
}
 
// ─── File System Nodes ─────────────────────────────────────────
 
interface FileSystemNode {
    name: string;
    path: string;
    accept<R>(visitor: FileSystemVisitor<R>): R;
}
 
class File implements FileSystemNode {
    constructor(
        public readonly name: string,
        public readonly path: string,
        public readonly size: number,
        public readonly mimeType: string,
        public readonly permissions: number,
        public readonly lastModified: Date
    ) {}
    
    accept<R>(visitor: FileSystemVisitor<R>): R {
        return visitor.visitFile(this);
    }
}
 
class Directory implements FileSystemNode {
    constructor(
        public readonly name: string,
        public readonly path: string,
        public readonly children: FileSystemNode[],
        public readonly permissions: number
    ) {}
    
    accept<R>(visitor: FileSystemVisitor<R>): R {
        return visitor.visitDirectory(this);
    }
}
 
class Symlink implements FileSystemNode {
    constructor(
        public readonly name: string,
        public readonly path: string,
        public readonly target: string,
        public readonly targetNode?: FileSystemNode
    ) {}
    
    accept<R>(visitor: FileSystemVisitor<R>): R {
        return visitor.visitSymlink(this);
    }
}
 
// ─── Size Calculator ───────────────────────────────────────────
 
class SizeCalculatorVisitor implements FileSystemVisitor<number> {
    private followSymlinks: boolean;
    private visited = new Set<string>();  // Avoid infinite loops
    
    constructor(options: { followSymlinks?: boolean } = {}) {
        this.followSymlinks = options.followSymlinks ?? false;
    }
    
    visitFile(file: File): number {
        return file.size;
    }
    
    visitDirectory(dir: Directory): number {
        return dir.children.reduce(
            (total, child) => total + child.accept(this),
            0
        );
    }
    
    visitSymlink(link: Symlink): number {
        if (!this.followSymlinks || !link.targetNode) {
            return 0;  // Symlink itself has negligible size
        }
        
        // Prevent infinite loops from circular symlinks
        if (this.visited.has(link.target)) {
            return 0;
        }
        this.visited.add(link.target);
        
        return link.targetNode.accept(this);
    }
}
 
// ─── File Search Visitor ───────────────────────────────────────
 
interface SearchCriteria {
    namePattern?: RegExp;
    mimeType?: string;
    minSize?: number;
    maxSize?: number;
    modifiedAfter?: Date;
    modifiedBefore?: Date;
}
 
class FileSearchVisitor implements FileSystemVisitor<File[]> {
    constructor(private criteria: SearchCriteria) {}
    
    visitFile(file: File): File[] {
        if (this.matches(file)) {
            return [file];
        }
        return [];
    }
    
    visitDirectory(dir: Directory): File[] {
        return dir.children.flatMap(child => child.accept(this));
    }
    
    visitSymlink(link: Symlink): File[] {
        // Don't follow symlinks for search to avoid duplicates
        return [];
    }
    
    private matches(file: File): boolean {
        const { namePattern, mimeType, minSize, maxSize, modifiedAfter, modifiedBefore } = this.criteria;
        
        if (namePattern && !namePattern.test(file.name)) return false;
        if (mimeType && file.mimeType !== mimeType) return false;
        if (minSize !== undefined && file.size < minSize) return false;
        if (maxSize !== undefined && file.size > maxSize) return false;
        if (modifiedAfter && file.lastModified < modifiedAfter) return false;
        if (modifiedBefore && file.lastModified > modifiedBefore) return false;
        
        return true;
    }
}
 
// ─── Permission Checker ────────────────────────────────────────
 
interface PermissionIssue {
    path: string;
    issue: string;
    severity: 'warning' | 'error';
}
 
class PermissionCheckVisitor implements FileSystemVisitor<PermissionIssue[]> {
    constructor(private userId: number, private groupId: number) {}
    
    visitFile(file: File): PermissionIssue[] {
        const issues: PermissionIssue[] = [];
        
        // Check for world-writable files
        if ((file.permissions & 0o002) !== 0) {
            issues.push({
                path: file.path,
                issue: 'File is world-writable',
                severity: 'error'
            });
        }
        
        // Check for executable files in unusual locations
        if ((file.permissions & 0o111) !== 0 && !file.path.includes('/bin/')) {
            issues.push({
                path: file.path,
                issue: 'Executable file outside bin directory',
                severity: 'warning'
            });
        }
        
        return issues;
    }
    
    visitDirectory(dir: Directory): PermissionIssue[] {
        const issues: PermissionIssue[] = [];
        
        // Check for world-writable directories
        if ((dir.permissions & 0o002) !== 0) {
            issues.push({
                path: dir.path,
                issue: 'Directory is world-writable',
                severity: 'error'
            });
        }
        
        // Recursively check children
        return issues.concat(
            dir.children.flatMap(child => child.accept(this))
        );
    }
    
    visitSymlink(link: Symlink): PermissionIssue[] {
        // Symlinks don't have meaningful permissions
        // But we might warn about broken symlinks
        if (!link.targetNode) {
            return [{
                path: link.path,
                issue: `Broken symlink pointing to ${link.target}`,
                severity: 'warning'
            }];
        }
        return [];
    }
}
 
// ─── Usage ─────────────────────────────────────────────────────
 
const fileSystem = new Directory('root', '/', [
    new File('readme.md', '/readme.md', 1024, 'text/markdown', 0o644, new Date()),
    new Directory('src', '/src', [
        new File('index.ts', '/src/index.ts', 5120, 'text/typescript', 0o644, new Date()),
        new File('app.ts', '/src/app.ts', 3072, 'text/typescript', 0o644, new Date()),
    ], 0o755),
    new Directory('dist', '/dist', [
        new File('index.js', '/dist/index.js', 10240, 'application/javascript', 0o755, new Date()),
    ], 0o755),
    new Symlink('link-to-src', '/link-to-src', '/src'),
], 0o755);
 
// Calculate total size
const sizeVisitor = new SizeCalculatorVisitor();
const totalSize = fileSystem.accept(sizeVisitor);
console.log(`Total size: ${totalSize} bytes`);
 
// Find TypeScript files
const searchVisitor = new FileSearchVisitor({
    namePattern: /\.ts$/
});
const tsFiles = fileSystem.accept(searchVisitor);
console.log(`TypeScript files: ${tsFiles.map(f => f.name).join(', ')}`);
 
// Check permissions
const permissionVisitor = new PermissionCheckVisitor(1000, 1000);
const issues = fileSystem.accept(permissionVisitor);
console.log(`Permission issues: ${issues.length}`);

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318

// ═══════════════════════════════════════════════════════════════
// GUI WIDGET VISITOR SYSTEM
// Demonstrates: Rendering, accessibility, serialization
// ═══════════════════════════════════════════════════════════════
 
// ─── Visitor Interface ─────────────────────────────────────────
 
interface WidgetVisitor<R> {
    visitButton(widget: Button): R;
    visitTextField(widget: TextField): R;
    visitLabel(widget: Label): R;
    visitPanel(widget: Panel): R;
    visitCheckbox(widget: Checkbox): R;
    visitDropdown(widget: Dropdown): R;
}
 
// ─── Widget Base and Types ─────────────────────────────────────
 
interface Widget {
    id: string;
    visible: boolean;
    enabled: boolean;
    accept<R>(visitor: WidgetVisitor<R>): R;
}
 
class Button implements Widget {
    constructor(
        public readonly id: string,
        public readonly text: string,
        public visible: boolean = true,
        public enabled: boolean = true,
        public onClick?: () => void
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitButton(this);
    }
}
 
class TextField implements Widget {
    constructor(
        public readonly id: string,
        public readonly placeholder: string,
        public value: string = '',
        public visible: boolean = true,
        public enabled: boolean = true,
        public readonly maxLength?: number
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitTextField(this);
    }
}
 
class Label implements Widget {
    constructor(
        public readonly id: string,
        public readonly text: string,
        public visible: boolean = true,
        public enabled: boolean = true
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitLabel(this);
    }
}
 
class Panel implements Widget {
    constructor(
        public readonly id: string,
        public readonly children: Widget[],
        public readonly direction: 'horizontal' | 'vertical' = 'vertical',
        public visible: boolean = true,
        public enabled: boolean = true
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitPanel(this);
    }
}
 
class Checkbox implements Widget {
    constructor(
        public readonly id: string,
        public readonly label: string,
        public checked: boolean = false,
        public visible: boolean = true,
        public enabled: boolean = true
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitCheckbox(this);
    }
}
 
class Dropdown implements Widget {
    constructor(
        public readonly id: string,
        public readonly options: string[],
        public selectedIndex: number = 0,
        public visible: boolean = true,
        public enabled: boolean = true
    ) {}
    
    accept<R>(visitor: WidgetVisitor<R>): R {
        return visitor.visitDropdown(this);
    }
}
 
// ─── HTML Render Visitor ───────────────────────────────────────
 
class HtmlRenderVisitor implements WidgetVisitor<string> {
    visitButton(widget: Button): string {
        const disabled = widget.enabled ? '' : ' disabled';
        const hidden = widget.visible ? '' : ' style="display:none"';
        return `<button id="${widget.id}"${disabled}${hidden}>${widget.text}</button>`;
    }
    
    visitTextField(widget: TextField): string {
        const disabled = widget.enabled ? '' : ' disabled';
        const hidden = widget.visible ? '' : ' style="display:none"';
        const maxLen = widget.maxLength ? ` maxlength="${widget.maxLength}"` : '';
        return `<input type="text" id="${widget.id}" placeholder="${widget.placeholder}" value="${widget.value}"${maxLen}${disabled}${hidden}>`;
    }
    
    visitLabel(widget: Label): string {
        const hidden = widget.visible ? '' : ' style="display:none"';
        return `<label id="${widget.id}"${hidden}>${widget.text}</label>`;
    }
    
    visitPanel(widget: Panel): string {
        const hidden = widget.visible ? '' : ' style="display:none"';
        const flexDir = widget.direction === 'horizontal' ? 'row' : 'column';
        const children = widget.children.map(c => c.accept(this)).join('\n  ');
        return `<div id="${widget.id}" style="display:flex;flex-direction:${flexDir}"${hidden}>\n  ${children}\n</div>`;
    }
    
    visitCheckbox(widget: Checkbox): string {
        const checked = widget.checked ? ' checked' : '';
        const disabled = widget.enabled ? '' : ' disabled';
        const hidden = widget.visible ? '' : ' style="display:none"';
        return `<label${hidden}><input type="checkbox" id="${widget.id}"${checked}${disabled}> ${widget.label}</label>`;
    }
    
    visitDropdown(widget: Dropdown): string {
        const disabled = widget.enabled ? '' : ' disabled';
        const hidden = widget.visible ? '' : ' style="display:none"';
        const options = widget.options.map((opt, i) => 
            `<option${i === widget.selectedIndex ? ' selected' : ''}>${opt}</option>`
        ).join('');
        return `<select id="${widget.id}"${disabled}${hidden}>${options}</select>`;
    }
}
 
// ─── Accessibility Checker ─────────────────────────────────────
 
interface AccessibilityIssue {
    widgetId: string;
    issue: string;
    severity: 'error' | 'warning' | 'info';
}
 
class AccessibilityVisitor implements WidgetVisitor<AccessibilityIssue[]> {
    visitButton(widget: Button): AccessibilityIssue[] {
        const issues: AccessibilityIssue[] = [];
        
        if (!widget.text || widget.text.trim().length === 0) {
            issues.push({
                widgetId: widget.id,
                issue: 'Button has no text - add aria-label for screen readers',
                severity: 'error'
            });
        }
        
        if (widget.text.length > 50) {
            issues.push({
                widgetId: widget.id,
                issue: 'Button text is very long - consider shortening',
                severity: 'warning'
            });
        }
        
        return issues;
    }
    
    visitTextField(widget: TextField): AccessibilityIssue[] {
        const issues: AccessibilityIssue[] = [];
        
        if (!widget.placeholder) {
            issues.push({
                widgetId: widget.id,
                issue: 'Text field has no placeholder - add label for accessibility',
                severity: 'warning'
            });
        }
        
        return issues;
    }
    
    visitLabel(widget: Label): AccessibilityIssue[] {
        // Labels are accessibility-friendly by nature
        return [];
    }
    
    visitPanel(widget: Panel): AccessibilityIssue[] {
        // Check children
        return widget.children.flatMap(child => child.accept(this));
    }
    
    visitCheckbox(widget: Checkbox): AccessibilityIssue[] {
        const issues: AccessibilityIssue[] = [];
        
        if (!widget.label) {
            issues.push({
                widgetId: widget.id,
                issue: 'Checkbox has no label',
                severity: 'error'
            });
        }
        
        return issues;
    }
    
    visitDropdown(widget: Dropdown): AccessibilityIssue[] {
        const issues: AccessibilityIssue[] = [];
        
        if (widget.options.length === 0) {
            issues.push({
                widgetId: widget.id,
                issue: 'Dropdown has no options',
                severity: 'error'
            });
        }
        
        return issues;
    }
}
 
// ─── State Serializer ──────────────────────────────────────────
 
interface WidgetState {
    id: string;
    type: string;
    visible: boolean;
    enabled: boolean;
    [key: string]: unknown;
}
 
class StateSerializerVisitor implements WidgetVisitor<WidgetState | WidgetState[]> {
    visitButton(widget: Button): WidgetState {
        return {
            id: widget.id,
            type: 'button',
            visible: widget.visible,
            enabled: widget.enabled,
            text: widget.text
        };
    }
    
    visitTextField(widget: TextField): WidgetState {
        return {
            id: widget.id,
            type: 'textField',
            visible: widget.visible,
            enabled: widget.enabled,
            value: widget.value,
            placeholder: widget.placeholder
        };
    }
    
    visitLabel(widget: Label): WidgetState {
        return {
            id: widget.id,
            type: 'label',
            visible: widget.visible,
            enabled: widget.enabled,
            text: widget.text
        };
    }
    
    visitPanel(widget: Panel): WidgetState {
        const children = widget.children.flatMap(c => {
            const result = c.accept(this);
            return Array.isArray(result) ? result : [result];
        });
        
        return {
            id: widget.id,
            type: 'panel',
            visible: widget.visible,
            enabled: widget.enabled,
            direction: widget.direction,
            children
        };
    }
    
    visitCheckbox(widget: Checkbox): WidgetState {
        return {
            id: widget.id,
            type: 'checkbox',
            visible: widget.visible,
            enabled: widget.enabled,
            label: widget.label,
            checked: widget.checked
        };
    }
    
    visitDropdown(widget: Dropdown): WidgetState {
        return {
            id: widget.id,
            type: 'dropdown',
            visible: widget.visible,
            enabled: widget.enabled,
            options: widget.options,
            selectedIndex: widget.selectedIndex
        };
    }
}