fieldMutateProtectedProxyHandler

fieldMutateProtectedProxyHandler.js

const fieldMutateProtectedProxyHandler = (() => {
    const MemberType = Object.freeze({
        PROPERTY: Symbol('PROPERTY'),
        METHOD: Symbol('METHOD'),
        FIELD: Symbol('FIELD'),
        UNKNOWN: Symbol('UNKNOWN')
    });

    function getMemberType(target, key) {
        if (!(key in target)) {
            return MemberType.UNKNOWN;
        }
    
        const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(target), key);
    
        if (descriptor.get || descriptor.set) {
            return MemberType.PROPERTY;
        }
    
        if (typeof descriptor.value === 'function') {
            return MemberType.METHOD;
        }
    
        return MemberType.UNKNOWN;
    }

    return {
        get(target, property) {
            const memberType = getMemberType(target, property);
    
            if (memberType === MemberType.FIELD) {
                throw new Error(`Field '${property}' cannot be read outside the class.`);
            }
    
            const result = target[property];
    
            if (memberType === MemberType.PROPERTY) {
                return result;
            }
    
            return (argumentsList) => result.apply(target, argumentsList);
        },
    
        set(target, property, value) {
            const memberType = getMemberType(target, property);
    
            if (memberType === MemberType.FIELD) {
                throw new TypeError(`Field '${property}' cannot be assigned outside the class.`);
            }
    
            if (memberType === MemberType.METHOD) {
                throw new TypeError(`Method '${property}' cannot be assigned.`);
            }
    
            console.log(memberType);
    
            target[property] = value;
    
            return true;
        }
    };
})();