Prototype Pattern: Object Cloning for Efficient Creation

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

// WITHOUT a registry: scattered prototype references
 
interface Shape {
    clone(): Shape;
    draw(): void;
}
 
class Circle implements Shape {
    constructor(public radius: number, public color: string) {}
    clone(): Circle { return new Circle(this.radius, this.color); }
    draw(): void { console.log(`Drawing ${this.color} circle, r=${this.radius}`); }
}
 
class Rectangle implements Shape {
    constructor(public width: number, public height: number, public color: string) {}
    clone(): Rectangle { return new Rectangle(this.width, this.height, this.color); }
    draw(): void { console.log(`Drawing ${this.color} rectangle`); }
}
 
// Problem 1: Must maintain individual prototype references
const redCirclePrototype = new Circle(50, "red");
const blueCirclePrototype = new Circle(30, "blue");
const greenRectPrototype = new Rectangle(100, 50, "green");
 
// Problem 2: Client code needs to know about all prototypes
function createShape(type: string): Shape | null {
    // This function must know about every prototype!
    switch (type) {
        case "red-circle": return redCirclePrototype.clone();
        case "blue-circle": return blueCirclePrototype.clone();
        case "green-rect": return greenRectPrototype.clone();
        default: return null;
    }
}
 
// Problem 3: Adding new types requires modifying factory code
// What if a plugin wants to register a "star" shape?
// What if user creates a custom "my-special-circle" prototype?
 
// Problem 4: Prototypes are scattered across the codebase
// Where is the single source of truth for available shapes?
 
// Problem 5: No introspection
// How do we list all available shape types?
// How do we check if a type exists before cloning?

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

// Production-quality Prototype Registry
 
interface Prototype<T> {
    clone(): T;
}
 
class PrototypeRegistry<T extends Prototype<T>> {
    private readonly prototypes: Map<string, T> = new Map();
    
    /**
     * Register a prototype with a unique key.
     * @throws Error if key already exists (use replace to update)
     */
    register(key: string, prototype: T): void {
        if (this.prototypes.has(key)) {
            throw new Error(
                `Prototype with key "${key}" already registered. ` +
                `Use replace() to update or unregister() first.`
            );
        }
        this.prototypes.set(key, prototype);
    }
    
    /**
     * Replace an existing prototype or register new.
     * Returns the previously registered prototype, if any.
     */
    replace(key: string, prototype: T): T | undefined {
        const previous = this.prototypes.get(key);
        this.prototypes.set(key, prototype);
        return previous;
    }
    
    /**
     * Remove a prototype from the registry.
     * Returns true if removed, false if not found.
     */
    unregister(key: string): boolean {
        return this.prototypes.delete(key);
    }
    
    /**
     * Check if a prototype exists.
     */
    has(key: string): boolean {
        return this.prototypes.has(key);
    }
    
    /**
     * Get a CLONE of the registered prototype.
     * Returns undefined if not found.
     */
    create(key: string): T | undefined {
        const prototype = this.prototypes.get(key);
        return prototype?.clone();
    }
    
    /**
     * Get a clone or throw if not found.
     */
    createOrThrow(key: string): T {
        const prototype = this.prototypes.get(key);
        if (!prototype) {
            throw new Error(
                `No prototype registered with key "${key}". ` +
                `Available: [${this.keys().join(", ")}]`
            );
        }
        return prototype.clone();
    }
    
    /**
     * Get direct reference to prototype (for inspection, not for use).
     * WARNING: Do not modify the returned prototype!
     */
    getPrototype(key: string): T | undefined {
        return this.prototypes.get(key);
    }
    
    /**
     * List all registered keys.
     */
    keys(): string[] {
        return Array.from(this.prototypes.keys());
    }
    
    /**
     * Get count of registered prototypes.
     */
    get size(): number {
        return this.prototypes.size;
    }
    
    /**
     * Clear all prototypes.
     */
    clear(): void {
        this.prototypes.clear();
    }
    
    /**
     * Register multiple prototypes at once.
     */
    registerAll(prototypes: Record<string, T>): void {
        for (const [key, prototype] of Object.entries(prototypes)) {
            this.register(key, prototype);
        }
    }
}
 
// ============================================
// Usage Example: Shape Registry
// ============================================
 
interface Shape extends Prototype<Shape> {
    draw(): void;
    getType(): string;
}
 
class Circle implements Shape {
    constructor(
        private radius: number,
        private color: string
    ) {}
    
    clone(): Circle {
        return new Circle(this.radius, this.color);
    }
    
    draw(): void {
        console.log(`Drawing ${this.color} circle, radius ${this.radius}`);
    }
    
    getType(): string { return "circle"; }
}
 
class Rectangle implements Shape {
    constructor(
        private width: number,
        private height: number,
        private color: string
    ) {}
    
    clone(): Rectangle {
        return new Rectangle(this.width, this.height, this.color);
    }
    
    draw(): void {
        console.log(`Drawing ${this.color} rectangle ${this.width}x${this.height}`);
    }
    
    getType(): string { return "rectangle"; }
}
 
// Create and populate registry
const shapeRegistry = new PrototypeRegistry<Shape>();
 
shapeRegistry.registerAll({
    "small-red-circle": new Circle(25, "red"),
    "large-blue-circle": new Circle(100, "blue"),
    "standard-button": new Rectangle(150, 40, "gray"),
    "wide-banner": new Rectangle(800, 100, "navy"),
});
 
// Client code uses string keys - no type knowledge needed
const shape1 = shapeRegistry.createOrThrow("small-red-circle");
const shape2 = shapeRegistry.createOrThrow("standard-button");
 
shape1.draw();  // "Drawing red circle, radius 25"
shape2.draw();  // "Drawing gray rectangle 150x40"
 
// List available shapes
console.log("Available shapes:", shapeRegistry.keys());
// ["small-red-circle", "large-blue-circle", "standard-button", "wide-banner"]
 
// Check existence before creating
if (shapeRegistry.has("custom-shape")) {
    const custom = shapeRegistry.create("custom-shape");
}

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

// Hierarchical Registry with parent chain lookup
 
interface Prototype<T> {
    clone(): T;
}
 
class HierarchicalPrototypeRegistry<T extends Prototype<T>> {
    private readonly prototypes: Map<string, T> = new Map();
    private readonly parent: HierarchicalPrototypeRegistry<T> | null;
    
    constructor(parent: HierarchicalPrototypeRegistry<T> | null = null) {
        this.parent = parent;
    }
    
    /**
     * Create a child registry that inherits from this registry.
     */
    createChild(): HierarchicalPrototypeRegistry<T> {
        return new HierarchicalPrototypeRegistry(this);
    }
    
    /**
     * Register a prototype at this level.
     */
    register(key: string, prototype: T): void {
        this.prototypes.set(key, prototype);
    }
    
    /**
     * Check if key exists at this level (not inherited).
     */
    hasOwn(key: string): boolean {
        return this.prototypes.has(key);
    }
    
    /**
     * Check if key exists anywhere in the hierarchy.
     */
    has(key: string): boolean {
        if (this.prototypes.has(key)) return true;
        if (this.parent) return this.parent.has(key);
        return false;
    }
    
    /**
     * Create a clone, walking up the hierarchy to find the prototype.
     */
    create(key: string): T | undefined {
        // First, check this registry
        const local = this.prototypes.get(key);
        if (local) return local.clone();
        
        // Then, check parent chain
        if (this.parent) return this.parent.create(key);
        
        return undefined;
    }
    
    /**
     * Get all keys available, including inherited ones.
     */
    allKeys(): string[] {
        const keys = new Set<string>(this.prototypes.keys());
        
        if (this.parent) {
            for (const key of this.parent.allKeys()) {
                keys.add(key);  // Set handles duplicates
            }
        }
        
        return Array.from(keys);
    }
    
    /**
     * Get keys defined only at this level.
     */
    ownKeys(): string[] {
        return Array.from(this.prototypes.keys());
    }
    
    /**
     * Remove from this level only.
     */
    unregister(key: string): boolean {
        return this.prototypes.delete(key);
    }
}
 
// ============================================
// Usage: Application with Global, Module, and User Levels
// ============================================
 
interface Button extends Prototype<Button> {
    render(): string;
}
 
class StandardButton implements Button {
    constructor(
        private label: string,
        private color: string,
        private size: string
    ) {}
    
    clone(): StandardButton {
        return new StandardButton(this.label, this.color, this.size);
    }
    
    render(): string {
        return `[${this.size} ${this.color} button: ${this.label}]`;
    }
}
 
// LEVEL 1: Global defaults (application-wide)
const globalRegistry = new HierarchicalPrototypeRegistry<Button>();
globalRegistry.register("primary", new StandardButton("Click", "blue", "medium"));
globalRegistry.register("secondary", new StandardButton("Cancel", "gray", "medium"));
globalRegistry.register("danger", new StandardButton("Delete", "red", "medium"));
 
// LEVEL 2: Module-specific registry (inherits global, adds/overrides)
const adminModuleRegistry = globalRegistry.createChild();
adminModuleRegistry.register("danger", new StandardButton("CONFIRM DELETE", "darkred", "large"));
adminModuleRegistry.register("admin-action", new StandardButton("Admin Only", "purple", "medium"));
 
// LEVEL 3: User-specific registry (inherits module, adds overrides)
const userRegistry = adminModuleRegistry.createChild();
userRegistry.register("primary", new StandardButton("Click Me!", "green", "small"));
 
// Usage from different contexts:
 
// Global context gets global defaults
const globalBtn = globalRegistry.create("primary")!;
console.log(globalBtn.render());  // [medium blue button: Click]
 
// Admin module gets overridden danger button
const adminDanger = adminModuleRegistry.create("danger")!;
console.log(adminDanger.render());  // [large darkred button: CONFIRM DELETE]
 
// Admin module still inherits non-overridden buttons
const adminSecondary = adminModuleRegistry.create("secondary")!;
console.log(adminSecondary.render());  // [medium gray button: Cancel]
 
// User gets their custom primary
const userPrimary = userRegistry.create("primary")!;
console.log(userPrimary.render());  // [small green button: Click Me!]
 
// User inherits admin's danger (which overrode global)
const userDanger = userRegistry.create("danger")!;
console.log(userDanger.render());  // [large darkred button: CONFIRM DELETE]
 
// User inherits admin-only button
const userAdmin = userRegistry.create("admin-action")!;
console.log(userAdmin.render());  // [medium purple button: Admin Only]
 
// Introspection
console.log("User's all keys:", userRegistry.allKeys());
// ["primary", "danger", "admin-action", "secondary"]
 
console.log("User's own keys:", userRegistry.ownKeys());
// ["primary"]

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

// Lazy-loading Prototype Registry
 
interface Prototype<T> {
    clone(): T;
}
 
// Factory functions create prototypes on demand
type PrototypeFactory<T> = () => T;
 
class LazyPrototypeRegistry<T extends Prototype<T>> {
    // Eagerly loaded prototypes
    private readonly prototypes: Map<string, T> = new Map();
    
    // Lazy factories (not yet instantiated)
    private readonly factories: Map<string, PrototypeFactory<T>> = new Map();
    
    /**
     * Register an already-created prototype.
     */
    register(key: string, prototype: T): void {
        this.factories.delete(key);  // Remove factory if exists
        this.prototypes.set(key, prototype);
    }
    
    /**
     * Register a factory function for lazy instantiation.
     * Prototype will be created on first access.
     */
    registerLazy(key: string, factory: PrototypeFactory<T>): void {
        this.prototypes.delete(key);  // Remove instance if exists
        this.factories.set(key, factory);
    }
    
    /**
     * Get or create prototype, then clone.
     */
    create(key: string): T | undefined {
        // Check if already instantiated
        let prototype = this.prototypes.get(key);
        
        if (!prototype) {
            // Try to instantiate from factory
            const factory = this.factories.get(key);
            if (factory) {
                console.log(`Lazily instantiating prototype: ${key}`);
                prototype = factory();
                this.prototypes.set(key, prototype);
                this.factories.delete(key);  // Factory no longer needed
            }
        }
        
        return prototype?.clone();
    }
    
    /**
     * Check if key exists (either as prototype or factory).
     */
    has(key: string): boolean {
        return this.prototypes.has(key) || this.factories.has(key);
    }
    
    /**
     * Get all registered keys (both loaded and lazy).
     */
    keys(): string[] {
        const allKeys = new Set([
            ...this.prototypes.keys(),
            ...this.factories.keys()
        ]);
        return Array.from(allKeys);
    }
    
    /**
     * Check what's actually loaded vs pending.
     */
    stats(): { loaded: number; pending: number } {
        return {
            loaded: this.prototypes.size,
            pending: this.factories.size
        };
    }
    
    /**
     * Force instantiation of all lazy prototypes.
     */
    preloadAll(): void {
        for (const [key, factory] of this.factories) {
            this.prototypes.set(key, factory());
        }
        this.factories.clear();
    }
}
 
// ============================================
// Usage: Lazy Loading Game Enemies
// ============================================
 
interface Enemy extends Prototype<Enemy> {
    attack(): void;
    name: string;
}
 
class Goblin implements Enemy {
    name = "Goblin";
    constructor(
        private health: number,
        private damage: number,
        private texture: string  // Expensive to load!
    ) {
        console.log("Loading Goblin texture: " + texture);
    }
    
    clone(): Goblin {
        return new Goblin(this.health, this.damage, this.texture);
    }
    
    attack(): void {
        console.log(`Goblin attacks for ${this.damage} damage!`);
    }
}
 
class Dragon implements Enemy {
    name = "Dragon";
    constructor(
        private health: number,
        private damage: number,
        private fireBreath: boolean,
        private animations: string[]  // Very expensive!
    ) {
        console.log("Loading Dragon with " + animations.length + " animations");
    }
    
    clone(): Dragon {
        return new Dragon(this.health, this.damage, this.fireBreath, [...this.animations]);
    }
    
    attack(): void {
        console.log(`Dragon attacks for ${this.damage} damage!`);
    }
}
 
// Create registry with lazy factories
const enemyRegistry = new LazyPrototypeRegistry<Enemy>();
 
// Register factories - NO work done yet!
enemyRegistry.registerLazy("goblin", () => 
    new Goblin(30, 5, "textures/goblin_base.png")
);
 
enemyRegistry.registerLazy("dragon", () => 
    new Dragon(500, 50, true, [
        "animations/dragon_fly.anim",
        "animations/dragon_attack.anim",
        "animations/dragon_breathe.anim",
    ])
);
 
console.log(enemyRegistry.stats());  // { loaded: 0, pending: 2 }
console.log("Available enemies:", enemyRegistry.keys());  // ["goblin", "dragon"]
 
// Player enters goblin area - NOW we load goblin
const goblin = enemyRegistry.create("goblin");
// Output: "Loading Goblin texture: textures/goblin_base.png"
//         "Lazily instantiating prototype: goblin"
 
console.log(enemyRegistry.stats());  // { loaded: 1, pending: 1 }
 
// Create more goblins - uses cached prototype (no loading)
const goblin2 = enemyRegistry.create("goblin");  // Silent - already loaded
 
// Dragon never loaded if player doesn't reach dragon area!
console.log(enemyRegistry.stats());  // Still { loaded: 1, pending: 1 }

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

// Configuration-driven Prototype Registry
 
// Prototype definition from config file
interface PrototypeConfig {
    type: string;  // Maps to a factory
    properties: Record<string, any>;
}
 
// Registry config (loaded from JSON/YAML/database)
interface RegistryConfig {
    prototypes: Record<string, PrototypeConfig>;
}
 
// Factory interface for creating prototypes from config
interface PrototypeFactory<T> {
    create(properties: Record<string, any>): T;
}
 
interface Prototype<T> {
    clone(): T;
}
 
class ConfigDrivenRegistry<T extends Prototype<T>> {
    private readonly prototypes: Map<string, T> = new Map();
    private readonly factories: Map<string, PrototypeFactory<T>> = new Map();
    
    /**
     * Register a factory for a prototype type.
     * Factories know how to create prototypes from config properties.
     */
    registerFactory(type: string, factory: PrototypeFactory<T>): void {
        this.factories.set(type, factory);
    }
    
    /**
     * Load prototypes from configuration.
     */
    loadFromConfig(config: RegistryConfig): void {
        for (const [key, protoConfig] of Object.entries(config.prototypes)) {
            const factory = this.factories.get(protoConfig.type);
            
            if (!factory) {
                console.warn(
                    `Unknown prototype type "${protoConfig.type}" for key "${key}". ` +
                    `Available types: [${Array.from(this.factories.keys()).join(", ")}]`
                );
                continue;
            }
            
            try {
                const prototype = factory.create(protoConfig.properties);
                this.prototypes.set(key, prototype);
                console.log(`Loaded prototype: ${key} (type: ${protoConfig.type})`);
            } catch (error) {
                console.error(`Failed to create prototype "${key}":`, error);
}
        }
    }
 
create(key: string): T | undefined {
    return this.prototypes.get(key)?.clone();
}
 
keys(): string[] {
    return Array.from(this.prototypes.keys());
}
}
 
// ============================================
// Example: Notification Templates
// ============================================
 
interface Notification extends Prototype<Notification> {
    send(recipient: string, data: Record<string, string>): void;
}
 
class EmailNotification implements Notification {
    constructor(
        private subject: string,
        private bodyTemplate: string,
        private fromAddress: string
    ) { }
 
    clone(): EmailNotification {
        return new EmailNotification(this.subject, this.bodyTemplate, this.fromAddress);
    }
 
    send(recipient: string, data: Record<string, string>): void {
        let body = this.bodyTemplate;
        for (const [key, value] of Object.entries(data)) {
            body = body.replace(`{{${key}}}`, value);
        }
        console.log(`Email to ${recipient}:`);
        console.log(`  From: ${this.fromAddress}`);
        console.log(`  Subject: ${this.subject}`);
        console.log(`  Body: ${body}`);
    }
}
 
class SMSNotification implements Notification {
    constructor(
        private messageTemplate: string,
        private fromNumber: string
    ) {}
    
    clone(): SMSNotification {
        return new SMSNotification(this.messageTemplate, this.fromNumber);
    }
    
    send(recipient: string, data: Record<string, string>): void {
        let message = this.messageTemplate;
        for (const [key, value] of Object.entries(data)) {
            message = message.replace(`{{${key}}}`, value);
        }
        console.log(`SMS to ${recipient} from ${this.fromNumber}: ${message}`);
    }
}
 
// Register factories
const notificationRegistry = new ConfigDrivenRegistry<Notification>();
 
notificationRegistry.registerFactory("email", {
    create(props) {
        return new EmailNotification(
            props.subject,
            props.bodyTemplate,
            props.fromAddress
        );
    }
});
 
notificationRegistry.registerFactory("sms", {
    create(props) {
        return new SMSNotification(
            props.messageTemplate,
            props.fromNumber
        );
    }
});
 
// Configuration loaded from file (in reality: JSON/YAML/database)
const config: RegistryConfig = {
    prototypes: {
        "welcome-email": {
            type: "email",
            properties: {
                subject: "Welcome to Our Platform, {{userName}}!",
                bodyTemplate: "Hello {{userName}}, thank you for joining.",
                fromAddress: "hello@example.com"
            }
        },
        "password-reset-email": {
            type: "email",
            properties: {
                subject: "Password Reset Request",
                bodyTemplate: "Click here to reset: {{resetLink}}",
                fromAddress: "security@example.com"
            }
        },
        "order-sms": {
            type: "sms",
            properties: {
                messageTemplate: "Order {{orderId}} shipped! Track: {{trackingUrl}}",
                fromNumber: "+1-555-0123"
            }
        }
    }
};
 
// Load from config
notificationRegistry.loadFromConfig(config);
 
// Use notifications - marketing team can add new templates without code changes!
const welcome = notificationRegistry.create("welcome-email")!;
welcome.send("user@test.com", { userName: "Alice" });
 
const orderSms = notificationRegistry.create("order-sms")!;
orderSms.send("+1-555-9876", { orderId: "12345", trackingUrl: "track.example.com/12345" });

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

// Plugin Architecture with Prototype Registry
 
// ============================================
// CORE APPLICATION (provided by app vendor)
// ============================================
 
interface Prototype<T> {
    clone(): T;
}
 
interface Widget extends Prototype<Widget> {
    readonly type: string;
    render(): string;
    configure(options: Record<string, any>): void;
}
 
// Global widget registry exposed to plugins
class WidgetRegistry {
    private static instance: WidgetRegistry;
    private readonly widgets: Map<string, Widget> = new Map();
    
    static getInstance(): WidgetRegistry {
        if (!WidgetRegistry.instance) {
            WidgetRegistry.instance = new WidgetRegistry();
        }
        return WidgetRegistry.instance;
    }
    
    register(key: string, widget: Widget): void {
        if (this.widgets.has(key)) {
            console.warn(`Widget "${key}" already registered, overwriting.`);
        }
        this.widgets.set(key, widget);
        console.log(`Registered widget: ${key}`);
    }
    
    create(key: string): Widget | undefined {
        return this.widgets.get(key)?.clone();
    }
    
    getAvailableWidgets(): string[] {
        return Array.from(this.widgets.keys());
    }
}
 
// Plugin interface definition
interface Plugin {
    name: string;
    version: string;
    initialize(registry: WidgetRegistry): void;
}
 
// Application plugin loader
class PluginLoader {
    private readonly loadedPlugins: Plugin[] = [];
    private readonly registry: WidgetRegistry;
    
    constructor(registry: WidgetRegistry) {
        this.registry = registry;
    }
    
    loadPlugin(plugin: Plugin): void {
        console.log(`Loading plugin: ${plugin.name} v${plugin.version}`);
        plugin.initialize(this.registry);
        this.loadedPlugins.push(plugin);
        console.log(`Plugin ${plugin.name} loaded successfully.\n`);
    }
    
    getLoadedPlugins(): string[] {
        return this.loadedPlugins.map(p => `${p.name} v${p.version}`);
    }
}
 
// Built-in widgets (core application)
class TextWidget implements Widget {
    readonly type = "text";
    private content: string = "";
    
    constructor(private fontSize: number = 14) {}
    
    clone(): TextWidget {
        const copy = new TextWidget(this.fontSize);
        copy.content = this.content;
        return copy;
    }
    
    render(): string {
        return `<div style="font-size: ${this.fontSize}px">${this.content}</div>`;
    }
    
    configure(options: Record<string, any>): void {
        if (options.content) this.content = options.content;
        if (options.fontSize) this.fontSize = options.fontSize;
    }
}
 
class ImageWidget implements Widget {
    readonly type = "image";
    private src: string = "";
    private alt: string = "";
    
    clone(): ImageWidget {
        const copy = new ImageWidget();
        copy.src = this.src;
        copy.alt = this.alt;
        return copy;
    }
    
    render(): string {
        return `<img src="${this.src}" alt="${this.alt}" />`;
    }
    
    configure(options: Record<string, any>): void {
        if (options.src) this.src = options.src;
        if (options.alt) this.alt = options.alt;
    }
}
 
// ============================================
// PLUGINS (provided by third parties)
// ============================================
 
// Plugin: Chart Widgets
const chartPlugin: Plugin = {
    name: "Chart Widgets",
    version: "1.2.0",
    
    initialize(registry: WidgetRegistry): void {
        class BarChartWidget implements Widget {
            readonly type = "bar-chart";
            private data: number[] = [];
            private labels: string[] = [];
            
            clone(): BarChartWidget {
                const copy = new BarChartWidget();
                copy.data = [...this.data];
                copy.labels = [...this.labels];
                return copy;
            }
            
            render(): string {
                return `<div class="bar-chart">Chart: ${this.labels.join(", ")}</div>`;
            }
            
            configure(options: Record<string, any>): void {
                if (options.data) this.data = options.data;
                if (options.labels) this.labels = options.labels;
            }
        }
        
        class PieChartWidget implements Widget {
            readonly type = "pie-chart";
            private segments: { label: string; value: number }[] = [];
            
            clone(): PieChartWidget {
                const copy = new PieChartWidget();
                copy.segments = this.segments.map(s => ({ ...s }));
                return copy;
            }
            
            render(): string {
                return `<div class="pie-chart">Pie: ${this.segments.length} segments</div>`;
            }
            
            configure(options: Record<string, any>): void {
                if (options.segments) this.segments = options.segments;
            }
        }
        
        registry.register("bar-chart", new BarChartWidget());
        registry.register("pie-chart", new PieChartWidget());
    }
};
 
// Plugin: Social Widgets
const socialPlugin: Plugin = {
    name: "Social Media Widgets",
    version: "2.0.1",
    
    initialize(registry: WidgetRegistry): void {
        class TwitterFeedWidget implements Widget {
            readonly type = "twitter-feed";
            private username: string = "";
            private tweetCount: number = 5;
            
            clone(): TwitterFeedWidget {
                const copy = new TwitterFeedWidget();
                copy.username = this.username;
                copy.tweetCount = this.tweetCount;
                return copy;
            }
            
            render(): string {
                return `<div class="twitter-feed">@${this.username}'s last ${this.tweetCount} tweets</div>`;
            }
            
            configure(options: Record<string, any>): void {
                if (options.username) this.username = options.username;
                if (options.tweetCount) this.tweetCount = options.tweetCount;
            }
        }
        
        registry.register("twitter-feed", new TwitterFeedWidget());
    }
};
 
// ============================================
// APPLICATION STARTUP
// ============================================
 
// Initialize registry with core widgets
const registry = WidgetRegistry.getInstance();
registry.register("text", new TextWidget());
registry.register("image", new ImageWidget());
 
// Load plugins
const loader = new PluginLoader(registry);
loader.loadPlugin(chartPlugin);
loader.loadPlugin(socialPlugin);
 
// See all available widgets
console.log("Available widgets:", registry.getAvailableWidgets());
// ["text", "image", "bar-chart", "pie-chart", "twitter-feed"]
 
// Create widgets from registry
const chart = registry.create("bar-chart")!;
chart.configure({ labels: ["Q1", "Q2", "Q3", "Q4"], data: [100, 150, 200, 180] });
console.log(chart.render());
 
const feed = registry.create("twitter-feed")!;
feed.configure({ username: "nodejs", tweetCount: 3 });
console.log(feed.render());

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

// Thread-safe Prototype Registry in Java
 
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
public class ThreadSafePrototypeRegistry<T extends Prototype<T>> {
    // ConcurrentHashMap for basic thread-safe read/write
    private final ConcurrentHashMap<String, T> prototypes = 
        new ConcurrentHashMap<>();
    
    // Lazy factories need additional synchronization
    private final ConcurrentHashMap<String, Supplier<T>> factories = 
        new ConcurrentHashMap<>();
    
    // Lock for lazy initialization to prevent double-creation
    private final ReadWriteLock lazyLock = new ReentrantReadWriteLock();
    
    /**
     * Register an eagerly created prototype.
     */
    public void register(String key, T prototype) {
        // ConcurrentHashMap.put is thread-safe
        prototypes.put(key, prototype);
        factories.remove(key);  // Remove any lazy factory
    }
    
    /**
     * Register a lazy factory.
     */
    public void registerLazy(String key, Supplier<T> factory) {
        prototypes.remove(key);  // Remove any eager prototype
        factories.put(key, factory);
    }
    
    /**
     * Thread-safe create with lazy initialization handling.
     */
    public Optional<T> create(String key) {
        // Fast path: check if already instantiated
        T prototype = prototypes.get(key);
        if (prototype != null) {
            return Optional.of(prototype.clone());
        }
        
        // Check if lazy factory exists
        Supplier<T> factory = factories.get(key);
        if (factory == null) {
            return Optional.empty();
        }
        
        // Lazy initialization with double-checked locking
        lazyLock.readLock().lock();
        try {
            prototype = prototypes.get(key);
            if (prototype != null) {
                return Optional.of(prototype.clone());
            }
        } finally {
            lazyLock.readLock().unlock();
        }
        
        // Upgrade to write lock for instantiation
        lazyLock.writeLock().lock();
        try {
            // Double-check after acquiring write lock
            prototype = prototypes.get(key);
            if (prototype != null) {
                return Optional.of(prototype.clone());
            }
            
            // Actually instantiate
            prototype = factory.get();
            prototypes.put(key, prototype);
            factories.remove(key);
            
            return Optional.of(prototype.clone());
        } finally {
            lazyLock.writeLock().unlock();
        }
    }
    
    /**
     * Get snapshot of keys (iteration-safe).
     */
    public Set<String> keys() {
        Set<String> allKeys = new HashSet<>();
        allKeys.addAll(prototypes.keySet());
        allKeys.addAll(factories.keySet());
        return Collections.unmodifiableSet(allKeys);
    }
}
 
// Usage in multi-threaded context
ExecutorService executor = Executors.newFixedThreadPool(10);
ThreadSafePrototypeRegistry<Widget> registry = new ThreadSafePrototypeRegistry<>();
 
registry.register("button", new ButtonWidget());
registry.registerLazy("chart", () -> {
    System.out.println("Creating chart prototype in thread: " + 
        Thread.currentThread().getName());
    return new ChartWidget();
});
 
// Multiple threads accessing registry concurrently
for (int i = 0; i < 20; i++) {
    executor.submit(() -> {
        // Safe: multiple threads can create concurrently
        Widget button = registry.create("button").orElseThrow();
        button.configure(Map.of("label", Thread.currentThread().getName()));
        
        // Safe: lazy factory called only once despite concurrent access
        Widget chart = registry.create("chart").orElseThrow();
    });
}