SandboxedFunction-Archive/deepproxy.js at master · DNSCond/SandboxedFunction-Archive · GitHub

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
//deepproxy.js
function DeepProxy(target) {
    if (new.target) {
        throw new TypeError("DeepProxy must be invoked without 'new'");
    }
    target = Object(target);
    const imaginary = new Map(); // Use a Map to handle objects with symbolic keys
    const handler = {
        get(target, prop, receiver) {
            if (imaginary.has(prop)) {
                return imaginary.get(prop);
            }
            const value = Reflect.get(target, prop, receiver);
            // Wrap nested objects in a new DeepProxy
            if (typeOf(value, typeOf.functionsAreObjects) === 'object') {
                return DeepProxy(value); // Recursive wrapping
            }
            return value;
        },
        set(target, prop, value, receiver) {
            imaginary.set(prop, value); // Store in the imaginary object
            return true;
        },
        has(target, prop) {
            return imaginary.has(prop) || Reflect.has(target, prop);
        },
        deleteProperty(target, prop) {
            if (imaginary.has(prop)) {
                imaginary.delete(prop);
                return true;
            }
            return false;
        },
        ownKeys(target) {
            return [...new Set([...Reflect.ownKeys(target), ...imaginary.keys()])];
        },
        getOwnPropertyDescriptor(target, prop) {
            if (imaginary.has(prop)) {
                return {
                    configurable: true,
                    enumerable: true,
                    value: imaginary.get(prop),
                    writable: true,
                };
            }
            return Reflect.getOwnPropertyDescriptor(target, prop);
        },
    };

    return new Proxy(target, handler);
}

// function DeepProxy(target) {
//     if (!!new.target) {
//         //called without new
//         throw new TypeError("DeepProxy must be invoked without 'new'");
//     }
//     const imaginarySymbol = Symbol('imaginary');
//     const imaginary = {};
//     const handler = {
//         get(target, prop, receiver) {
//             // Check if the property exists in the imaginary object first
//             if (prop in imaginary) {
//                 return imaginary[prop];
//             }
//             // Fall back to the target object
//             return Reflect.get(target, prop, receiver);
//         },
//         set(target, prop, value, receiver) {
//             // Modify only the imaginary object
//             imaginary[prop] = value;
//             return true; // Indicate success
//         },
//         has(target, prop) {
//             // Check both imaginary and target for property existence
//             return prop in imaginary || Reflect.has(target, prop);
//         },
//         deleteProperty(target, prop) {
//             // Delete property only from the imaginary object
//             if (prop in imaginary) {
//                 delete imaginary[prop];
//                 return true;
//             }
//             return false;
//         },
//     };
//     const proxy = new Proxy(target, {
//         get(target, prop, receiver) {
//             const value = Reflect.get(target, prop, receiver);
//             // If the value is an object, wrap it in a Proxy
//             if (typeof value === "object" && value !== null) {
//                 return new DeepProxy(value, handler);
//             }
//             return value;
//         },
//         ...handler,
//     });
//     proxy[imaginarySymbol] = imaginary;
//     return proxy;
// }

// function DeepProxy(target) {
//     if (!new.target) {
//         //called without new
//         throw new TypeError("DeepProxy must be invoked with 'new'");
//     }
//     const imaginary = this.imaginary = {};
//     this.proxy = new Proxy(target, {
//         get(target, prop, receiver) {
//             // Check if the property exists in the imaginary object first
//             if (prop in imaginary) {
//                 return imaginary[prop];
//             }
//             // Fall back to the target object
//             return Reflect.get(target, prop, receiver);
//         },
//         set(target, prop, value, receiver) {
//             // Modify only the imaginary object
//             imaginary[prop] = value;
//             return true; // Indicate success
//         },
//         has(target, prop) {
//             // Check both imaginary and target for property existence
//             return prop in imaginary || Reflect.has(target, prop);
//         },
//         deleteProperty(target, prop) {
//             // Delete property only from the imaginary object
//             if (prop in imaginary) {
//                 delete imaginary[prop];
//                 return true;
//             }
//             return false;
//         },
//     });
// }