Rename internal cache helpers (#20410)
Dan Abramov committed
Dec 9, 2020 at 02:57 UTC
a233c9e2aa121d6cb27f37115ace83fe81aaf349
4 files changed
+145
-138
packages/react-fetch/src/ReactFetchBrowser.js
+45
-40
@@ -15,63 +15,63 @@ const Pending = 0;
15
const Resolved = 1;
16
const Rejected = 2;
17
18
-type PendingResult = {|
18
+type PendingRecord = {|
19
status: 0,
20
value: Wakeable,
21
|};
22
23
-type ResolvedResult = {|
23
+type ResolvedRecord = {|
24
status: 1,
25
value: mixed,
26
|};
27
28
-type RejectedResult = {|
28
+type RejectedRecord = {|
29
status: 2,
30
value: mixed,
31
|};
32
33
-type Result = PendingResult | ResolvedResult | RejectedResult;
33
+type Record = PendingRecord | ResolvedRecord | RejectedRecord;
34
35
// TODO: this is a browser-only version. Add a separate Node entry point.
36
const nativeFetch = window.fetch;
37
38
-function getResultMap(): Map<string, Result> {
39
- return unstable_getCacheForType(createResultMap);
38
+function getRecordMap(): Map<string, Record> {
39
+ return unstable_getCacheForType(createRecordMap);
40
}
41
42
-function createResultMap(): Map<string, Result> {
42
+function createRecordMap(): Map<string, Record> {
43
return new Map();
44
}
45
46
-function toResult(thenable): Result {
47
- const result: Result = {
46
+function createRecordFromThenable(thenable): Record {
47
+ const record: Record = {
48
status: Pending,
49
value: thenable,
50
};
51
thenable.then(
52
value => {
53
- if (result.status === Pending) {
54
- const resolvedResult = ((result: any): ResolvedResult);
55
- resolvedResult.status = Resolved;
56
- resolvedResult.value = value;
53
+ if (record.status === Pending) {
54
+ const resolvedRecord = ((record: any): ResolvedRecord);
55
+ resolvedRecord.status = Resolved;
56
+ resolvedRecord.value = value;
57
}
58
},
59
err => {
60
- if (result.status === Pending) {
61
- const rejectedResult = ((result: any): RejectedResult);
62
- rejectedResult.status = Rejected;
63
- rejectedResult.value = err;
60
+ if (record.status === Pending) {
61
+ const rejectedRecord = ((record: any): RejectedRecord);
62
+ rejectedRecord.status = Rejected;
63
+ rejectedRecord.value = err;
64
}
65
},
66
);
67
- return result;
67
+ return record;
68
}
69
70
-function readResult(result: Result) {
71
- if (result.status === Resolved) {
72
- return result.value;
70
+function readRecordValue(record: Record) {
71
+ if (record.status === Resolved) {
72
+ return record.value;
73
} else {
74
- throw result.value;
74
+ throw record.value;
75
}
76
}
77
@@ -94,32 +94,37 @@ function Response(nativeResponse) {
94
Response.prototype = {
95
constructor: Response,
96
arrayBuffer() {
97
- return readResult(
97
+ return readRecordValue(
98
this._arrayBuffer ||
99
- (this._arrayBuffer = toResult(this._response.arrayBuffer())),
99
+ (this._arrayBuffer = createRecordFromThenable(
100
+ this._response.arrayBuffer(),
101
+ )),
102
);
103
},
104
blob() {
103
- return readResult(
104
- this._blob || (this._blob = toResult(this._response.blob())),
105
+ return readRecordValue(
106
+ this._blob ||
107
+ (this._blob = createRecordFromThenable(this._response.blob())),
108
);
109
},
110
json() {
108
- return readResult(
109
- this._json || (this._json = toResult(this._response.json())),
111
+ return readRecordValue(
112
+ this._json ||
113
+ (this._json = createRecordFromThenable(this._response.json())),
114
);
115
},
116
text() {
113
- return readResult(
114
- this._text || (this._text = toResult(this._response.text())),
117
+ return readRecordValue(
118
+ this._text ||
119
+ (this._text = createRecordFromThenable(this._response.text())),
120
);
121
},
122
};
123
119
-function preloadResult(url: string, options: mixed): Result {
120
- const map = getResultMap();
121
- let entry = map.get(url);
122
- if (!entry) {
124
+function preloadRecord(url: string, options: mixed): Record {
125
+ const map = getRecordMap();
126
+ let record = map.get(url);
127
+ if (!record) {
128
if (options) {
129
if (options.method || options.body || options.signal) {
130
// TODO: wire up our own cancellation mechanism.
@@ -128,20 +133,20 @@ function preloadResult(url: string, options: mixed): Result {
133
}
134
}
135
const thenable = nativeFetch(url, options);
131
- entry = toResult(thenable);
132
- map.set(url, entry);
136
+ record = createRecordFromThenable(thenable);
137
+ map.set(url, record);
138
}
134
- return entry;
139
+ return record;
140
}
141
142
export function preload(url: string, options: mixed): void {
138
- preloadResult(url, options);
143
+ preloadRecord(url, options);
144
// Don't return anything.
145
}
146
147
export function fetch(url: string, options: mixed): Object {
143
- const result = preloadResult(url, options);
144
- const nativeResponse = (readResult(result): any);
148
+ const record = preloadRecord(url, options);
149
+ const nativeResponse = (readRecordValue(record): any);
150
if (nativeResponse._reactResponse) {
151
return nativeResponse._reactResponse;
152
} else {
packages/react-fetch/src/ReactFetchNode.js
+42
-41
@@ -57,36 +57,36 @@ const Pending = 0;
57
const Resolved = 1;
58
const Rejected = 2;
59
60
-type PendingResult = {|
60
+type PendingRecord = {|
61
status: 0,
62
value: Wakeable,
63
|};
64
65
-type ResolvedResult<V> = {|
65
+type ResolvedRecord<V> = {|
66
status: 1,
67
value: V,
68
|};
69
70
-type RejectedResult = {|
70
+type RejectedRecord = {|
71
status: 2,
72
value: mixed,
73
|};
74
75
-type Result<V> = PendingResult | ResolvedResult<V> | RejectedResult;
75
+type Record<V> = PendingRecord | ResolvedRecord<V> | RejectedRecord;
76
77
-function getResultMap(): Map<string, Result<FetchResponse>> {
78
- return unstable_getCacheForType(createResultMap);
77
+function getRecordMap(): Map<string, Record<FetchResponse>> {
78
+ return unstable_getCacheForType(createRecordMap);
79
}
80
81
-function createResultMap(): Map<string, Result<FetchResponse>> {
81
+function createRecordMap(): Map<string, Record<FetchResponse>> {
82
return new Map();
83
}
84
85
-function readResult<T>(result: Result<T>): T {
86
- if (result.status === Resolved) {
87
- return result.value;
85
+function readRecordValue<T>(record: Record<T>): T {
86
+ if (record.status === Resolved) {
87
+ return record.value;
88
} else {
89
- throw result.value;
89
+ throw record.value;
90
}
91
}
92
@@ -111,7 +111,7 @@ function Response(nativeResponse) {
111
cb();
112
}
113
}
114
- const result: PendingResult = (this._result = {
114
+ const bufferRecord: PendingRecord = (this._bufferRecord = {
115
status: Pending,
116
value: {
117
then(cb) {
@@ -122,18 +122,18 @@ function Response(nativeResponse) {
122
const data = [];
123
nativeResponse.on('data', chunk => data.push(chunk));
124
nativeResponse.on('end', () => {
125
- if (result.status === Pending) {
126
- const resolvedResult = ((result: any): ResolvedResult<Buffer>);
127
- resolvedResult.status = Resolved;
128
- resolvedResult.value = Buffer.concat(data);
125
+ if (bufferRecord.status === Pending) {
126
+ const resolvedRecord = ((bufferRecord: any): ResolvedRecord<Buffer>);
127
+ resolvedRecord.status = Resolved;
128
+ resolvedRecord.value = Buffer.concat(data);
129
wake();
130
}
131
});
132
nativeResponse.on('error', err => {
133
- if (result.status === Pending) {
134
- const rejectedResult = ((result: any): RejectedResult);
135
- rejectedResult.status = Rejected;
136
- rejectedResult.value = err;
133
+ if (bufferRecord.status === Pending) {
134
+ const rejectedRecord = ((bufferRecord: any): RejectedRecord);
135
+ rejectedRecord.status = Rejected;
136
+ rejectedRecord.value = err;
137
wake();
138
}
139
});
@@ -142,7 +142,7 @@ function Response(nativeResponse) {
142
Response.prototype = {
143
constructor: Response,
144
arrayBuffer() {
145
- const buffer = readResult(this._result);
145
+ const buffer = readRecordValue(this._bufferRecord);
146
return buffer;
147
},
148
blob() {
@@ -153,7 +153,7 @@ Response.prototype = {
153
if (this._json !== null) {
154
return this._json;
155
}
156
- const buffer = readResult(this._result);
156
+ const buffer = readRecordValue(this._bufferRecord);
157
const json = JSON.parse(buffer.toString());
158
this._json = json;
159
return json;
@@ -162,17 +162,17 @@ Response.prototype = {
162
if (this._text !== null) {
163
return this._text;
164
}
165
- const buffer = readResult(this._result);
165
+ const buffer = readRecordValue(this._bufferRecord);
166
const text = buffer.toString();
167
this._text = text;
168
return text;
169
},
170
};
171
172
-function preloadResult(url: string, options: mixed): Result<FetchResponse> {
173
- const map = getResultMap();
174
- let entry = map.get(url);
175
- if (!entry) {
172
+function preloadRecord(url: string, options: mixed): Record<FetchResponse> {
173
+ const map = getRecordMap();
174
+ let record = map.get(url);
175
+ if (!record) {
176
if (options) {
177
if (options.method || options.body || options.signal) {
178
// TODO: wire up our own cancellation mechanism.
@@ -193,7 +193,7 @@ function preloadResult(url: string, options: mixed): Result<FetchResponse> {
193
cb();
194
}
195
};
196
- const result: Result<FetchResponse> = (entry = {
196
+ const newRecord: Record<FetchResponse> = (record = {
197
status: Pending,
198
value: wakeable,
199
});
@@ -201,33 +201,34 @@ function preloadResult(url: string, options: mixed): Result<FetchResponse> {
201
url,
202
options,
203
response => {
204
- if (result.status === Pending) {
205
- const resolvedResult = ((result: any): ResolvedResult<FetchResponse>);
206
- resolvedResult.status = Resolved;
207
- resolvedResult.value = response;
204
+ if (newRecord.status === Pending) {
205
+ const resolvedRecord = ((newRecord: any): ResolvedRecord<FetchResponse>);
206
+ resolvedRecord.status = Resolved;
207
+ resolvedRecord.value = response;
208
wake();
209
}
210
},
211
err => {
212
- if (result.status === Pending) {
213
- const rejectedResult = ((result: any): RejectedResult);
214
- rejectedResult.status = Rejected;
215
- rejectedResult.value = err;
212
+ if (newRecord.status === Pending) {
213
+ const rejectedRecord = ((newRecord: any): RejectedRecord);
214
+ rejectedRecord.status = Rejected;
215
+ rejectedRecord.value = err;
216
wake();
217
}
218
},
219
);
220
- map.set(url, entry);
220
+ map.set(url, record);
221
}
222
- return entry;
222
+ return record;
223
}
224
225
export function preload(url: string, options: mixed): void {
226
- preloadResult(url, options);
226
+ preloadRecord(url, options);
227
// Don't return anything.
228
}
229
230
export function fetch(url: string, options: mixed): FetchResponse {
231
- const result = preloadResult(url, options);
232
- return readResult(result);
231
+ const record = preloadRecord(url, options);
232
+ const response = readRecordValue(record);
233
+ return response;
234
}
packages/react-fs/src/ReactFilesystem.js
+29
-29
@@ -17,56 +17,56 @@ const Pending = 0;
17
const Resolved = 1;
18
const Rejected = 2;
19
20
-type PendingResult = {|
20
+type PendingRecord = {|
21
status: 0,
22
value: Wakeable,
23
cache: Array<mixed>,
24
|};
25
26
-type ResolvedResult<T> = {|
26
+type ResolvedRecord<T> = {|
27
status: 1,
28
value: T,
29
cache: Array<mixed>,
30
|};
31
32
-type RejectedResult = {|
32
+type RejectedRecord = {|
33
status: 2,
34
value: mixed,
35
cache: Array<mixed>,
36
|};
37
38
-type Result<T> = PendingResult | ResolvedResult<T> | RejectedResult;
38
+type Record<T> = PendingRecord | ResolvedRecord<T> | RejectedRecord;
39
40
-function toResult<T>(thenable: Thenable<T>): Result<T> {
41
- const result: Result<T> = {
40
+function createRecordFromThenable<T>(thenable: Thenable<T>): Record<T> {
41
+ const record: Record<T> = {
42
status: Pending,
43
value: thenable,
44
cache: [],
45
};
46
thenable.then(
47
value => {
48
- if (result.status === Pending) {
49
- const resolvedResult = ((result: any): ResolvedResult<T>);
50
- resolvedResult.status = Resolved;
51
- resolvedResult.value = value;
48
+ if (record.status === Pending) {
49
+ const resolvedRecord = ((record: any): ResolvedRecord<T>);
50
+ resolvedRecord.status = Resolved;
51
+ resolvedRecord.value = value;
52
}
53
},
54
err => {
55
- if (result.status === Pending) {
56
- const rejectedResult = ((result: any): RejectedResult);
57
- rejectedResult.status = Rejected;
58
- rejectedResult.value = err;
55
+ if (record.status === Pending) {
56
+ const rejectedRecord = ((record: any): RejectedRecord);
57
+ rejectedRecord.status = Rejected;
58
+ rejectedRecord.value = err;
59
}
60
},
61
);
62
- return result;
62
+ return record;
63
}
64
65
-function readResult<T>(result: Result<T>): T {
66
- if (result.status === Resolved) {
67
- return result.value;
65
+function readRecordValue<T>(record: Record<T>): T {
66
+ if (record.status === Resolved) {
67
+ return record.value;
68
} else {
69
- throw result.value;
69
+ throw record.value;
70
}
71
}
72
@@ -91,7 +91,7 @@ function checkPathInDev(path: string) {
91
}
92
}
93
94
-function createReadFileCache(): Map<string, Result<Buffer>> {
94
+function createReadFileCache(): Map<string, Record<Buffer>> {
95
return new Map();
96
}
97
@@ -108,15 +108,15 @@ export function readFile(
108
): string | Buffer {
109
const map = unstable_getCacheForType(createReadFileCache);
110
checkPathInDev(path);
111
- let entry = map.get(path);
112
- if (!entry) {
111
+ let record = map.get(path);
112
+ if (!record) {
113
const thenable = fs.readFile(path);
114
- entry = toResult(thenable);
115
- map.set(path, entry);
114
+ record = createRecordFromThenable(thenable);
115
+ map.set(path, record);
116
}
117
- const result: Buffer = readResult(entry);
117
+ const buffer: Buffer = readRecordValue(record);
118
if (!options) {
119
- return result;
119
+ return buffer;
120
}
121
let encoding;
122
if (typeof options === 'string') {
@@ -134,15 +134,15 @@ export function readFile(
134
encoding = options.encoding;
135
}
136
if (typeof encoding !== 'string') {
137
- return result;
137
+ return buffer;
138
}
139
- const textCache = entry.cache;
139
+ const textCache = record.cache;
140
for (let i = 0; i < textCache.length; i += 2) {
141
if (textCache[i] === encoding) {
142
return (textCache[i + 1]: any);
143
}
144
}
145
- const text = result.toString((encoding: any));
145
+ const text = buffer.toString((encoding: any));
146
textCache.push(encoding, text);
147
return text;
148
}
packages/react-pg/src/ReactPostgres.js
+29
-28
@@ -18,68 +18,68 @@ const Pending = 0;
18
const Resolved = 1;
19
const Rejected = 2;
20
21
-type PendingResult = {|
21
+type PendingRecord = {|
22
status: 0,
23
value: Wakeable,
24
|};
25
26
-type ResolvedResult = {|
26
+type ResolvedRecord = {|
27
status: 1,
28
value: mixed,
29
|};
30
31
-type RejectedResult = {|
31
+type RejectedRecord = {|
32
status: 2,
33
value: mixed,
34
|};
35
36
-type Result = PendingResult | ResolvedResult | RejectedResult;
36
+type Record = PendingRecord | ResolvedRecord | RejectedRecord;
37
38
-function toResult(thenable): Result {
39
- const result: Result = {
38
+function createRecordFromThenable(thenable): Record {
39
+ const record: Record = {
40
status: Pending,
41
value: thenable,
42
};
43
thenable.then(
44
value => {
45
- if (result.status === Pending) {
46
- const resolvedResult = ((result: any): ResolvedResult);
47
- resolvedResult.status = Resolved;
48
- resolvedResult.value = value;
45
+ if (record.status === Pending) {
46
+ const resolvedRecord = ((record: any): ResolvedRecord);
47
+ resolvedRecord.status = Resolved;
48
+ resolvedRecord.value = value;
49
}
50
},
51
err => {
52
- if (result.status === Pending) {
53
- const rejectedResult = ((result: any): RejectedResult);
54
- rejectedResult.status = Rejected;
55
- rejectedResult.value = err;
52
+ if (record.status === Pending) {
53
+ const rejectedRecord = ((record: any): RejectedRecord);
54
+ rejectedRecord.status = Rejected;
55
+ rejectedRecord.value = err;
56
}
57
},
58
);
59
- return result;
59
+ return record;
60
}
61
62
-function readResult(result: Result) {
63
- if (result.status === Resolved) {
64
- return result.value;
62
+function readRecordValue(record: Record) {
63
+ if (record.status === Resolved) {
64
+ return record.value;
65
} else {
66
- throw result.value;
66
+ throw record.value;
67
}
68
}
69
70
export function Pool(options: mixed) {
71
this.pool = new PostgresPool(options);
72
// Unique function per instance because it's used for cache identity.
73
- this.createResultMap = function() {
73
+ this.createRecordMap = function() {
74
return new Map();
75
};
76
}
77
78
-type NestedMap = Map<any, Result | NestedMap>;
78
+type NestedMap = Map<any, Record | NestedMap>;
79
80
Pool.prototype.query = function(query: string, values?: Array<mixed>) {
81
const pool = this.pool;
82
- const outerMap = unstable_getCacheForType(this.createResultMap);
82
+ const outerMap = unstable_getCacheForType(this.createRecordMap);
83
84
let innerMap: NestedMap = outerMap;
85
let key = query;
@@ -107,12 +107,12 @@ Pool.prototype.query = function(query: string, values?: Array<mixed>) {
107
}
108
}
109
110
- let entry = innerMap.get(key);
111
- if (!entry) {
110
+ let record = innerMap.get(key);
111
+ if (!record) {
112
const thenable = pool.query(query, values);
113
- entry = toResult(thenable);
114
- innerMap.set(key, entry);
115
- } else if (entry instanceof Map) {
113
+ record = createRecordFromThenable(thenable);
114
+ innerMap.set(key, record);
115
+ } else if (record instanceof Map) {
116
invariant(
117
false,
118
'This query has received fewer parameters than the last time ' +
@@ -120,5 +120,6 @@ Pool.prototype.query = function(query: string, values?: Array<mixed>) {
120
'parameters that the query needs.',
121
);
122
}
123
- return readResult(entry);
123
+ const result = readRecordValue(record);
124
+ return result;
125
};