UNPKG

18 kBJavaScriptView Raw
1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3exports.ZipExplodedHTTP = void 0;
4var tslib_1 = require("tslib");
5var debug_ = require("debug");
6var request = require("request");
7var requestPromise = require("request-promise-native");
8var stream_1 = require("stream");
9var url_1 = require("url");
10var zip_1 = require("./zip");
11var debug = debug_("r2:utils#zip/zip-ex-http");
12var 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));
309exports.ZipExplodedHTTP = ZipExplodedHTTP;
310//# sourceMappingURL=zip-ex-http.js.map
\No newline at end of file