1 | ;
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | exports.ZipExplodedHTTP = void 0;
|
4 | var tslib_1 = require("tslib");
|
5 | var debug_ = require("debug");
|
6 | var request = require("request");
|
7 | var requestPromise = require("request-promise-native");
|
8 | var stream_1 = require("stream");
|
9 | var url_1 = require("url");
|
10 | var zip_1 = require("./zip");
|
11 | var debug = debug_("r2:utils#zip/zip-ex-http");
|
12 | var ZipExplodedHTTP = (function (_super) {
|
13 | tslib_1.__extends(ZipExplodedHTTP, _super);
|
14 | function ZipExplodedHTTP(urlStr) {
|
15 | var _this = _super.call(this) || this;
|
16 | _this.urlStr = urlStr;
|
17 | debug("ZipExplodedHTTP: ".concat(urlStr));
|
18 | return _this;
|
19 | }
|
20 | ZipExplodedHTTP.loadPromise = function (urlStr) {
|
21 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
22 | return tslib_1.__generator(this, function (_a) {
|
23 | return [2, Promise.resolve(new ZipExplodedHTTP(urlStr))];
|
24 | });
|
25 | });
|
26 | };
|
27 | ZipExplodedHTTP.prototype.freeDestroy = function () {
|
28 | debug("freeDestroy: ZipExplodedHTTP -- " + this.urlStr);
|
29 | };
|
30 | ZipExplodedHTTP.prototype.entriesCount = function () {
|
31 | return 0;
|
32 | };
|
33 | ZipExplodedHTTP.prototype.hasEntries = function () {
|
34 | return true;
|
35 | };
|
36 | ZipExplodedHTTP.prototype.hasEntry = function (_entryPath) {
|
37 | return true;
|
38 | };
|
39 | ZipExplodedHTTP.prototype.hasEntryAsync = function (entryPath) {
|
40 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
41 | var url, urlStrEntry;
|
42 | var _this = this;
|
43 | return tslib_1.__generator(this, function (_a) {
|
44 | debug("hasEntryAsync: ".concat(entryPath));
|
45 | url = new url_1.URL(this.urlStr);
|
46 | url.pathname += entryPath;
|
47 | urlStrEntry = url.toString();
|
48 | debug("urlStrEntry: ", urlStrEntry);
|
49 | return [2, new Promise(function (topresolve, _topreject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
50 | var failure, success, needsStreamingResponse, promise, _err_1, response, err_1;
|
51 | var _this = this;
|
52 | return tslib_1.__generator(this, function (_a) {
|
53 | switch (_a.label) {
|
54 | case 0:
|
55 | failure = function (err) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
56 | return tslib_1.__generator(this, function (_a) {
|
57 | debug(err);
|
58 | topresolve(false);
|
59 | return [2];
|
60 | });
|
61 | }); };
|
62 | success = function (response) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
63 | return tslib_1.__generator(this, function (_a) {
|
64 | if (response.statusCode && (response.statusCode < 200 || response.statusCode >= 300)) {
|
65 | topresolve(false);
|
66 | return [2];
|
67 | }
|
68 | topresolve(true);
|
69 | return [2];
|
70 | });
|
71 | }); };
|
72 | needsStreamingResponse = true;
|
73 | if (!needsStreamingResponse) return [3, 5];
|
74 | promise = new Promise(function (resolve, reject) {
|
75 | request.get({
|
76 | headers: {},
|
77 | method: "HEAD",
|
78 | uri: urlStrEntry,
|
79 | })
|
80 | .on("response", function (response) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
81 | var successError_1;
|
82 | return tslib_1.__generator(this, function (_a) {
|
83 | switch (_a.label) {
|
84 | case 0:
|
85 | _a.trys.push([0, 2, , 4]);
|
86 | return [4, success(response)];
|
87 | case 1:
|
88 | _a.sent();
|
89 | return [3, 4];
|
90 | case 2:
|
91 | successError_1 = _a.sent();
|
92 | return [4, failure(successError_1)];
|
93 | case 3:
|
94 | _a.sent();
|
95 | return [2];
|
96 | case 4:
|
97 | resolve();
|
98 | return [2];
|
99 | }
|
100 | });
|
101 | }); })
|
102 | .on("error", function (err) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
103 | return tslib_1.__generator(this, function (_a) {
|
104 | switch (_a.label) {
|
105 | case 0: return [4, failure(err)];
|
106 | case 1:
|
107 | _a.sent();
|
108 | reject();
|
109 | return [2];
|
110 | }
|
111 | });
|
112 | }); });
|
113 | });
|
114 | _a.label = 1;
|
115 | case 1:
|
116 | _a.trys.push([1, 3, , 4]);
|
117 | return [4, promise];
|
118 | case 2:
|
119 | _a.sent();
|
120 | return [3, 4];
|
121 | case 3:
|
122 | _err_1 = _a.sent();
|
123 | return [3, 4];
|
124 | case 4: return [3, 11];
|
125 | case 5:
|
126 | response = void 0;
|
127 | _a.label = 6;
|
128 | case 6:
|
129 | _a.trys.push([6, 9, , 11]);
|
130 | return [4, requestPromise({
|
131 | headers: {},
|
132 | method: "HEAD",
|
133 | resolveWithFullResponse: true,
|
134 | uri: urlStrEntry,
|
135 | })];
|
136 | case 7:
|
137 | response = _a.sent();
|
138 | return [4, success(response)];
|
139 | case 8:
|
140 | _a.sent();
|
141 | return [3, 11];
|
142 | case 9:
|
143 | err_1 = _a.sent();
|
144 | return [4, failure(err_1)];
|
145 | case 10:
|
146 | _a.sent();
|
147 | return [3, 11];
|
148 | case 11: return [2];
|
149 | }
|
150 | });
|
151 | }); })];
|
152 | });
|
153 | });
|
154 | };
|
155 | ZipExplodedHTTP.prototype.getEntries = function () {
|
156 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
157 | var _this = this;
|
158 | return tslib_1.__generator(this, function (_a) {
|
159 | return [2, new Promise(function (_resolve, reject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
160 | return tslib_1.__generator(this, function (_a) {
|
161 | reject("Not implemented.");
|
162 | return [2];
|
163 | });
|
164 | }); })];
|
165 | });
|
166 | });
|
167 | };
|
168 | ZipExplodedHTTP.prototype.entryStreamPromise = function (entryPath) {
|
169 | return tslib_1.__awaiter(this, void 0, void 0, function () {
|
170 | var url, urlStrEntry;
|
171 | var _this = this;
|
172 | return tslib_1.__generator(this, function (_a) {
|
173 | debug("entryStreamPromise: ".concat(entryPath));
|
174 | url = new url_1.URL(this.urlStr);
|
175 | url.pathname += entryPath;
|
176 | urlStrEntry = url.toString();
|
177 | debug("urlStrEntry: ", urlStrEntry);
|
178 | return [2, new Promise(function (topresolve, topreject) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
179 | var failure, success, needsStreamingResponse, promise, _err_2, response, err_2;
|
180 | var _this = this;
|
181 | return tslib_1.__generator(this, function (_a) {
|
182 | switch (_a.label) {
|
183 | case 0:
|
184 | failure = function (err) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
185 | return tslib_1.__generator(this, function (_a) {
|
186 | debug(err);
|
187 | topreject(err);
|
188 | return [2];
|
189 | });
|
190 | }); };
|
191 | success = function (response) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
192 | var length, lengthStr, stream, streamAndLength;
|
193 | var _this = this;
|
194 | return tslib_1.__generator(this, function (_a) {
|
195 | switch (_a.label) {
|
196 | case 0:
|
197 | if (!(response.statusCode && (response.statusCode < 200 || response.statusCode >= 300))) return [3, 2];
|
198 | return [4, failure("HTTP CODE " + response.statusCode)];
|
199 | case 1:
|
200 | _a.sent();
|
201 | return [2];
|
202 | case 2:
|
203 | length = 0;
|
204 | lengthStr = response.headers["content-length"];
|
205 | if (lengthStr) {
|
206 | length = parseInt(lengthStr, 10);
|
207 | }
|
208 | stream = new stream_1.PassThrough();
|
209 | response.pipe(stream);
|
210 | streamAndLength = {
|
211 | length: length,
|
212 | reset: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
213 | return tslib_1.__generator(this, function (_a) {
|
214 | return [2, this.entryStreamPromise(entryPath)];
|
215 | });
|
216 | }); },
|
217 | stream: stream,
|
218 | };
|
219 | topresolve(streamAndLength);
|
220 | return [2];
|
221 | }
|
222 | });
|
223 | }); };
|
224 | needsStreamingResponse = true;
|
225 | if (!needsStreamingResponse) return [3, 5];
|
226 | promise = new Promise(function (resolve, reject) {
|
227 | request.get({
|
228 | headers: {},
|
229 | method: "GET",
|
230 | uri: urlStrEntry,
|
231 | })
|
232 | .on("response", function (response) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
233 | var successError_2;
|
234 | return tslib_1.__generator(this, function (_a) {
|
235 | switch (_a.label) {
|
236 | case 0:
|
237 | _a.trys.push([0, 2, , 4]);
|
238 | return [4, success(response)];
|
239 | case 1:
|
240 | _a.sent();
|
241 | return [3, 4];
|
242 | case 2:
|
243 | successError_2 = _a.sent();
|
244 | return [4, failure(successError_2)];
|
245 | case 3:
|
246 | _a.sent();
|
247 | return [2];
|
248 | case 4:
|
249 | resolve();
|
250 | return [2];
|
251 | }
|
252 | });
|
253 | }); })
|
254 | .on("error", function (err) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
|
255 | return tslib_1.__generator(this, function (_a) {
|
256 | switch (_a.label) {
|
257 | case 0: return [4, failure(err)];
|
258 | case 1:
|
259 | _a.sent();
|
260 | reject();
|
261 | return [2];
|
262 | }
|
263 | });
|
264 | }); });
|
265 | });
|
266 | _a.label = 1;
|
267 | case 1:
|
268 | _a.trys.push([1, 3, , 4]);
|
269 | return [4, promise];
|
270 | case 2:
|
271 | _a.sent();
|
272 | return [3, 4];
|
273 | case 3:
|
274 | _err_2 = _a.sent();
|
275 | return [3, 4];
|
276 | case 4: return [3, 11];
|
277 | case 5:
|
278 | response = void 0;
|
279 | _a.label = 6;
|
280 | case 6:
|
281 | _a.trys.push([6, 9, , 11]);
|
282 | return [4, requestPromise({
|
283 | headers: {},
|
284 | method: "GET",
|
285 | resolveWithFullResponse: true,
|
286 | uri: urlStrEntry,
|
287 | })];
|
288 | case 7:
|
289 | response = _a.sent();
|
290 | return [4, success(response)];
|
291 | case 8:
|
292 | _a.sent();
|
293 | return [3, 11];
|
294 | case 9:
|
295 | err_2 = _a.sent();
|
296 | return [4, failure(err_2)];
|
297 | case 10:
|
298 | _a.sent();
|
299 | return [3, 11];
|
300 | case 11: return [2];
|
301 | }
|
302 | });
|
303 | }); })];
|
304 | });
|
305 | });
|
306 | };
|
307 | return ZipExplodedHTTP;
|
308 | }(zip_1.Zip));
|
309 | exports.ZipExplodedHTTP = ZipExplodedHTTP;
|
310 | //# sourceMappingURL=zip-ex-http.js.map |
\ | No newline at end of file |