Prototype Chain Cache in JavaScript

Prototype chain caching is an optimization technique that can significantly improve performance when repeatedly accessing properties on objects with deep prototype chains. This challenge asks you to implement a basic prototype chain cache to avoid redundant property lookups. This is particularly useful in scenarios involving frequent property access on objects with complex inheritance hierarchies.

Problem Description

You are tasked with implementing a PrototypeChainCache class in JavaScript. This class will wrap an object and provide a mechanism to cache the results of property lookups along the prototype chain. When a property is accessed on the wrapped object, the cache will first check if the property has already been looked up in a particular prototype. If it has, the cached result will be returned. Otherwise, the property lookup will proceed as usual, the result will be cached, and then returned.

Key Requirements:

• Caching: The cache should store the results of property lookups for each prototype in the object's prototype chain.
• Prototype Traversal: The cache should traverse the prototype chain correctly, starting from the object itself and moving up to null.
• Property Lookup: The cache should correctly handle both own properties and inherited properties.
• No Modification of Original Object: The PrototypeChainCache should not modify the original object or its prototypes.
• Getter Interception: The cache should intercept property access using getOwnPropertyDescriptor and defineGetter.

Expected Behavior:

When a property is accessed on a PrototypeChainCache instance, the following should happen:

1. The cache checks if the property has already been looked up in the current prototype.
2. If the property is found in the cache for the current prototype, the cached value is returned.
3. If the property is not found in the cache, the standard prototype chain lookup is performed.
4. The result of the lookup is stored in the cache for the current prototype.
5. The result is returned.

Edge Cases to Consider:

• null Prototype: The prototype chain ends with null. The cache should handle this gracefully.
• Non-Enumerable Properties: The cache should handle non-enumerable properties correctly.
• Getter/Setter Functions: The cache should handle properties with getter functions.
• Deleting Properties: The cache does not need to handle property deletion. Assume properties are only added.
• Circular Prototype Chains: While unlikely, consider how your implementation would behave if a circular prototype chain were encountered. (It's acceptable to assume this won't happen for the purpose of this challenge).

Examples

Example 1:

const obj = { a: 1 };
const proto = { b: 2 };
obj.__proto__ = proto;
const cachedObj = new PrototypeChainCache(obj);

console.log(cachedObj.a); // Output: 1 (property lookup on obj)
console.log(cachedObj.b); // Output: 2 (property lookup on proto, cached)
console.log(cachedObj.b); // Output: 2 (cached value returned)

Explanation: The first access to b triggers a lookup on proto. The result (2) is cached. Subsequent accesses to b return the cached value.

Example 2:

const obj = {};
const proto1 = { c: 3 };
const proto2 = { d: 4 };
proto1.__proto__ = proto2;
obj.__proto__ = proto1;
const cachedObj = new PrototypeChainCache(obj);

console.log(cachedObj.c); // Output: 3 (lookup on proto1, cached)
console.log(cachedObj.d); // Output: 4 (lookup on proto2, cached)
console.log(cachedObj.c); // Output: 3 (cached value returned)
console.log(cachedObj.d); // Output: 4 (cached value returned)

Explanation: Demonstrates caching across multiple levels of the prototype chain.

Example 3: (Getter Function)

const obj = {};
const proto = {
  get e() { return 5; }
};
obj.__proto__ = proto;
const cachedObj = new PrototypeChainCache(obj);

console.log(cachedObj.e); // Output: 5 (getter function invoked, cached)
console.log(cachedObj.e); // Output: 5 (cached value returned)

Explanation: Shows that the getter function is invoked and its result is cached.

Constraints

• Time Complexity: Subsequent property accesses after the initial lookup should ideally be O(1) due to the cache. The initial lookup can be O(n) where n is the length of the prototype chain.
• Space Complexity: The space complexity should be proportional to the number of unique prototypes in the object's prototype chain.
• Input: The input will be a JavaScript object.
• No External Libraries: You are not allowed to use any external libraries.

Notes

• Consider using Object.getOwnPropertyDescriptor and Object.defineProperty to intercept property access.
• The cache should be implemented as part of the PrototypeChainCache class.
• Focus on the core caching functionality. Error handling and edge case robustness beyond those explicitly mentioned are not required.
• Think about how to efficiently store and retrieve cached values for each prototype. A simple JavaScript object (hash map) is a good starting point.
• The goal is to demonstrate understanding of prototype chains and caching principles, not to create a production-ready, highly optimized caching solution.