stage-browser 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (172) hide show
  1. package/README.md +92 -45
  2. package/build/icon.icns +0 -0
  3. package/build/icon.png +0 -0
  4. package/dist/bin/stage.js +111 -0
  5. package/dist/main/cli-args.js +28 -0
  6. package/dist/main/context-menu.js +68 -0
  7. package/dist/main/context.js +2 -0
  8. package/dist/main/extensions.js +78 -0
  9. package/dist/main/ipc.js +73 -0
  10. package/dist/main/main.js +282 -0
  11. package/dist/main/menu.js +140 -0
  12. package/dist/main/reveal.js +170 -0
  13. package/dist/main/selftest.js +570 -0
  14. package/dist/main/store.js +85 -0
  15. package/dist/main/suggest.js +43 -0
  16. package/dist/main/tabs.js +324 -0
  17. package/dist/main/ui-window.js +133 -0
  18. package/dist/main/url.js +38 -0
  19. package/dist/main/window.js +133 -0
  20. package/dist/preload/extension-compat.js +163 -0
  21. package/dist/preload/ui-preload.js +34 -0
  22. package/dist/shared/contract.js +6 -0
  23. package/dist/ui/app.js +692 -0
  24. package/{src → dist}/ui/index.html +15 -5
  25. package/dist/ui/mock.js +500 -0
  26. package/{src → dist}/ui/styles.css +55 -14
  27. package/node_modules/@types/chrome/LICENSE +21 -0
  28. package/node_modules/@types/chrome/README.md +15 -0
  29. package/node_modules/@types/chrome/chrome-cast/index.d.ts +1156 -0
  30. package/node_modules/@types/chrome/har-format/index.d.ts +6 -0
  31. package/node_modules/@types/chrome/index.d.ts +13786 -0
  32. package/node_modules/@types/chrome/package.json +99 -0
  33. package/node_modules/@types/filesystem/LICENSE +21 -0
  34. package/node_modules/@types/filesystem/README.md +15 -0
  35. package/node_modules/@types/filesystem/index.d.ts +564 -0
  36. package/node_modules/@types/filesystem/package.json +26 -0
  37. package/node_modules/@types/filewriter/LICENSE +21 -0
  38. package/node_modules/@types/filewriter/README.md +15 -0
  39. package/node_modules/@types/filewriter/index.d.ts +166 -0
  40. package/node_modules/@types/filewriter/package.json +25 -0
  41. package/node_modules/@types/har-format/LICENSE +21 -0
  42. package/node_modules/@types/har-format/README.md +15 -0
  43. package/node_modules/@types/har-format/index.d.ts +938 -0
  44. package/node_modules/@types/har-format/package.json +31 -0
  45. package/node_modules/adm-zip/LICENSE +21 -0
  46. package/node_modules/adm-zip/README.md +90 -0
  47. package/node_modules/adm-zip/adm-zip.js +1020 -0
  48. package/node_modules/adm-zip/headers/entryHeader.js +396 -0
  49. package/node_modules/adm-zip/headers/index.js +2 -0
  50. package/node_modules/adm-zip/headers/mainHeader.js +177 -0
  51. package/node_modules/adm-zip/methods/deflater.js +33 -0
  52. package/node_modules/adm-zip/methods/index.js +3 -0
  53. package/node_modules/adm-zip/methods/inflater.js +64 -0
  54. package/node_modules/adm-zip/methods/zipcrypto.js +175 -0
  55. package/node_modules/adm-zip/package.json +56 -0
  56. package/node_modules/adm-zip/types.d.ts +223 -0
  57. package/node_modules/adm-zip/util/constants.js +142 -0
  58. package/node_modules/adm-zip/util/decoder.js +5 -0
  59. package/node_modules/adm-zip/util/errors.js +66 -0
  60. package/node_modules/adm-zip/util/fattr.js +76 -0
  61. package/node_modules/adm-zip/util/index.js +5 -0
  62. package/node_modules/adm-zip/util/utils.js +481 -0
  63. package/node_modules/adm-zip/zipEntry.js +415 -0
  64. package/node_modules/adm-zip/zipFile.js +466 -0
  65. package/node_modules/debug/LICENSE +20 -0
  66. package/node_modules/debug/README.md +481 -0
  67. package/node_modules/debug/package.json +64 -0
  68. package/node_modules/debug/src/browser.js +272 -0
  69. package/node_modules/debug/src/common.js +292 -0
  70. package/node_modules/debug/src/index.js +10 -0
  71. package/node_modules/debug/src/node.js +263 -0
  72. package/node_modules/electron-chrome-web-store/README.md +143 -0
  73. package/node_modules/electron-chrome-web-store/dist/chrome-web-store.preload.js +299 -0
  74. package/node_modules/electron-chrome-web-store/dist/cjs/browser/index.js +1674 -0
  75. package/node_modules/electron-chrome-web-store/dist/esm/browser/index.mjs +950 -0
  76. package/node_modules/electron-chrome-web-store/dist/types/browser/api.d.ts +2 -0
  77. package/node_modules/electron-chrome-web-store/dist/types/browser/crx3.d.ts +20 -0
  78. package/node_modules/electron-chrome-web-store/dist/types/browser/id.d.ts +9 -0
  79. package/node_modules/electron-chrome-web-store/dist/types/browser/index.d.ts +62 -0
  80. package/node_modules/electron-chrome-web-store/dist/types/browser/installer.d.ts +29 -0
  81. package/node_modules/electron-chrome-web-store/dist/types/browser/loader.d.ts +18 -0
  82. package/node_modules/electron-chrome-web-store/dist/types/browser/types.d.ts +21 -0
  83. package/node_modules/electron-chrome-web-store/dist/types/browser/updater.d.ts +6 -0
  84. package/node_modules/electron-chrome-web-store/dist/types/browser/utils.d.ts +4 -0
  85. package/node_modules/electron-chrome-web-store/dist/types/common/constants.d.ts +44 -0
  86. package/node_modules/electron-chrome-web-store/dist/types/renderer/chrome-web-store.preload.d.ts +1 -0
  87. package/node_modules/electron-chrome-web-store/package.json +43 -0
  88. package/node_modules/ms/index.js +162 -0
  89. package/node_modules/ms/license.md +21 -0
  90. package/node_modules/ms/package.json +38 -0
  91. package/node_modules/ms/readme.md +59 -0
  92. package/node_modules/pbf/LICENSE +27 -0
  93. package/node_modules/pbf/README.md +293 -0
  94. package/node_modules/pbf/bin/pbf +17 -0
  95. package/node_modules/pbf/compile.js +441 -0
  96. package/node_modules/pbf/dist/pbf-dev.js +838 -0
  97. package/node_modules/pbf/dist/pbf.js +1 -0
  98. package/node_modules/pbf/index.d.ts +206 -0
  99. package/node_modules/pbf/index.js +830 -0
  100. package/node_modules/pbf/package.json +63 -0
  101. package/node_modules/protocol-buffers-schema/.travis.yml +7 -0
  102. package/node_modules/protocol-buffers-schema/LICENSE +21 -0
  103. package/node_modules/protocol-buffers-schema/README.md +122 -0
  104. package/node_modules/protocol-buffers-schema/example.js +11 -0
  105. package/node_modules/protocol-buffers-schema/example.proto +13 -0
  106. package/node_modules/protocol-buffers-schema/index.js +6 -0
  107. package/node_modules/protocol-buffers-schema/package.json +31 -0
  108. package/node_modules/protocol-buffers-schema/parse.js +769 -0
  109. package/node_modules/protocol-buffers-schema/stringify.js +206 -0
  110. package/node_modules/protocol-buffers-schema/test/fixtures/basic.json +90 -0
  111. package/node_modules/protocol-buffers-schema/test/fixtures/basic.proto +11 -0
  112. package/node_modules/protocol-buffers-schema/test/fixtures/comments.json +99 -0
  113. package/node_modules/protocol-buffers-schema/test/fixtures/comments.proto +19 -0
  114. package/node_modules/protocol-buffers-schema/test/fixtures/complex.json +125 -0
  115. package/node_modules/protocol-buffers-schema/test/fixtures/complex.proto +30 -0
  116. package/node_modules/protocol-buffers-schema/test/fixtures/enum.json +42 -0
  117. package/node_modules/protocol-buffers-schema/test/fixtures/enum.proto +8 -0
  118. package/node_modules/protocol-buffers-schema/test/fixtures/escaped-quotes.json +32 -0
  119. package/node_modules/protocol-buffers-schema/test/fixtures/escaped-quotes.proto +3 -0
  120. package/node_modules/protocol-buffers-schema/test/fixtures/extend.json +167 -0
  121. package/node_modules/protocol-buffers-schema/test/fixtures/extend.proto +19 -0
  122. package/node_modules/protocol-buffers-schema/test/fixtures/import.json +30 -0
  123. package/node_modules/protocol-buffers-schema/test/fixtures/import.proto +6 -0
  124. package/node_modules/protocol-buffers-schema/test/fixtures/map.json +33 -0
  125. package/node_modules/protocol-buffers-schema/test/fixtures/map.proto +3 -0
  126. package/node_modules/protocol-buffers-schema/test/fixtures/no-tags.proto +8 -0
  127. package/node_modules/protocol-buffers-schema/test/fixtures/oneof.json +41 -0
  128. package/node_modules/protocol-buffers-schema/test/fixtures/oneof.proto +6 -0
  129. package/node_modules/protocol-buffers-schema/test/fixtures/option.json +364 -0
  130. package/node_modules/protocol-buffers-schema/test/fixtures/option.proto +72 -0
  131. package/node_modules/protocol-buffers-schema/test/fixtures/options.json +47 -0
  132. package/node_modules/protocol-buffers-schema/test/fixtures/options.proto +8 -0
  133. package/node_modules/protocol-buffers-schema/test/fixtures/pheromon-trajectories.proto +8 -0
  134. package/node_modules/protocol-buffers-schema/test/fixtures/reserved.json +55 -0
  135. package/node_modules/protocol-buffers-schema/test/fixtures/reserved.proto +17 -0
  136. package/node_modules/protocol-buffers-schema/test/fixtures/search.json +30 -0
  137. package/node_modules/protocol-buffers-schema/test/fixtures/search.proto +5 -0
  138. package/node_modules/protocol-buffers-schema/test/fixtures/service.json +108 -0
  139. package/node_modules/protocol-buffers-schema/test/fixtures/service.proto +30 -0
  140. package/node_modules/protocol-buffers-schema/test/fixtures/valid-packed.proto +35 -0
  141. package/node_modules/protocol-buffers-schema/test/fixtures/version.json +90 -0
  142. package/node_modules/protocol-buffers-schema/test/fixtures/version.proto +13 -0
  143. package/node_modules/protocol-buffers-schema/test/index.js +157 -0
  144. package/node_modules/protocol-buffers-schema/tokenize.js +56 -0
  145. package/node_modules/resolve-protobuf-schema/.travis.yml +3 -0
  146. package/node_modules/resolve-protobuf-schema/LICENSE +21 -0
  147. package/node_modules/resolve-protobuf-schema/README.md +49 -0
  148. package/node_modules/resolve-protobuf-schema/index.js +50 -0
  149. package/node_modules/resolve-protobuf-schema/package.json +25 -0
  150. package/node_modules/resolve-protobuf-schema/test/a.proto +5 -0
  151. package/node_modules/resolve-protobuf-schema/test/b.proto +5 -0
  152. package/node_modules/resolve-protobuf-schema/test/c.proto +3 -0
  153. package/node_modules/resolve-protobuf-schema/test/index.js +49 -0
  154. package/package.json +35 -11
  155. package/bin/stage.js +0 -52
  156. package/src/main/cli-args.js +0 -28
  157. package/src/main/context-menu.js +0 -64
  158. package/src/main/extensions.js +0 -61
  159. package/src/main/main.js +0 -310
  160. package/src/main/menu.js +0 -171
  161. package/src/main/reveal.js +0 -141
  162. package/src/main/selftest.js +0 -383
  163. package/src/main/store.js +0 -77
  164. package/src/main/suggest.js +0 -50
  165. package/src/main/tabs.js +0 -351
  166. package/src/main/url.js +0 -37
  167. package/src/main/window.js +0 -71
  168. package/src/preload/extension-compat.js +0 -34
  169. package/src/preload/ui-preload.js +0 -40
  170. package/src/ui/app.js +0 -588
  171. package/src/ui/mock.js +0 -455
  172. /package/{src → dist}/ui/newtab.html +0 -0
@@ -0,0 +1,1020 @@
1
+ const Utils = require("./util");
2
+ const pth = require("path");
3
+ const ZipEntry = require("./zipEntry");
4
+ const ZipFile = require("./zipFile");
5
+
6
+ const get_Bool = (...val) => Utils.findLast(val, (c) => typeof c === "boolean");
7
+ const get_Str = (...val) => Utils.findLast(val, (c) => typeof c === "string");
8
+ const get_Fun = (...val) => Utils.findLast(val, (c) => typeof c === "function");
9
+
10
+ const defaultOptions = {
11
+ // option "noSort" : if true it disables files sorting
12
+ noSort: false,
13
+ // read entries during load (initial loading may be slower)
14
+ readEntries: false,
15
+ // default method is none
16
+ method: Utils.Constants.NONE,
17
+ // file system
18
+ fs: null
19
+ };
20
+
21
+ module.exports = function (/**String*/ input, /** object */ options) {
22
+ let inBuffer = null;
23
+
24
+ // create object based default options, allowing them to be overwritten
25
+ const opts = Object.assign(Object.create(null), defaultOptions);
26
+
27
+ // test input variable
28
+ if (input && "object" === typeof input) {
29
+ // if value is not buffer we accept it to be object with options
30
+ if (!(input instanceof Uint8Array)) {
31
+ Object.assign(opts, input);
32
+ input = opts.input ? opts.input : undefined;
33
+ if (opts.input) delete opts.input;
34
+ }
35
+
36
+ // if input is buffer
37
+ if (Buffer.isBuffer(input)) {
38
+ inBuffer = input;
39
+ opts.method = Utils.Constants.BUFFER;
40
+ input = undefined;
41
+ }
42
+ }
43
+
44
+ // assign options
45
+ Object.assign(opts, options);
46
+
47
+ // instanciate utils filesystem
48
+ const filetools = new Utils(opts);
49
+
50
+ // Restore the archived permissions on extracted directories. This has to run
51
+ // after a directory's contents are written: applying a restrictive mode
52
+ // (e.g. 0o500) up front would stop us writing the files it contains. Applying
53
+ // the deepest paths first keeps parent directories traversable while their
54
+ // children are updated (issue #530).
55
+ const applyDirAttributes = (dirEntries) => {
56
+ dirEntries
57
+ .filter((d) => d.attr)
58
+ .sort((a, b) => b.path.length - a.path.length)
59
+ .forEach((d) => filetools.fs.chmodSync(d.path, d.attr));
60
+ };
61
+
62
+ if (typeof opts.decoder !== "object" || typeof opts.decoder.encode !== "function" || typeof opts.decoder.decode !== "function") {
63
+ opts.decoder = Utils.decoder;
64
+ }
65
+
66
+ // if input is file name we retrieve its content
67
+ if (input && "string" === typeof input) {
68
+ // load zip file
69
+ if (filetools.fs.existsSync(input)) {
70
+ opts.method = Utils.Constants.FILE;
71
+ opts.filename = input;
72
+ inBuffer = filetools.fs.readFileSync(input);
73
+ } else {
74
+ throw Utils.Errors.INVALID_FILENAME();
75
+ }
76
+ }
77
+
78
+ // create variable
79
+ const _zip = new ZipFile(inBuffer, opts);
80
+
81
+ const { canonical, sanitize, zipnamefix } = Utils;
82
+
83
+ function getEntry(/**Object*/ entry) {
84
+ if (entry && _zip) {
85
+ var item;
86
+ // If entry was given as a file name
87
+ if (typeof entry === "string") item = _zip.getEntry(pth.posix.normalize(entry));
88
+ // if entry was given as a ZipEntry object
89
+ if (typeof entry === "object" && typeof entry.entryName !== "undefined" && typeof entry.header !== "undefined") item = _zip.getEntry(entry.entryName);
90
+
91
+ if (item) {
92
+ return item;
93
+ }
94
+ }
95
+ return null;
96
+ }
97
+
98
+ function fixPath(zipPath) {
99
+ const { join, normalize, sep } = pth.posix;
100
+ // convert windows file separators and normalize
101
+ return join(pth.isAbsolute(zipPath) ? "/": '.', normalize(sep + zipPath.split("\\").join(sep) + sep));
102
+ }
103
+
104
+ function filenameFilter(filterfn) {
105
+ if (filterfn instanceof RegExp) {
106
+ // if filter is RegExp wrap it
107
+ return (function (rx) {
108
+ return function (filename) {
109
+ return rx.test(filename);
110
+ };
111
+ })(filterfn);
112
+ } else if ("function" !== typeof filterfn) {
113
+ // if filter is not function we will replace it
114
+ return () => true;
115
+ }
116
+ return filterfn;
117
+ }
118
+
119
+ // keep last character on folders
120
+ const relativePath = (local, entry) => {
121
+ let lastChar = entry.slice(-1);
122
+ lastChar = lastChar === filetools.sep ? filetools.sep : "";
123
+ return pth.relative(local, entry) + lastChar;
124
+ };
125
+
126
+ return {
127
+ /**
128
+ * Extracts the given entry from the archive and returns the content as a Buffer object
129
+ * @param {ZipEntry|string} entry ZipEntry object or String with the full path of the entry
130
+ * @param {Buffer|string} [pass] - password
131
+ * @return Buffer or Null in case of error
132
+ */
133
+ readFile: function (entry, pass) {
134
+ var item = getEntry(entry);
135
+ return (item && item.getData(pass)) || null;
136
+ },
137
+
138
+ /**
139
+ * Returns how many child elements has on entry (directories) on files it is always 0
140
+ * @param {ZipEntry|string} entry ZipEntry object or String with the full path of the entry
141
+ * @returns {integer}
142
+ */
143
+ childCount: function (entry) {
144
+ const item = getEntry(entry);
145
+ if (item) {
146
+ return _zip.getChildCount(item);
147
+ }
148
+ },
149
+
150
+ /**
151
+ * Asynchronous readFile
152
+ * @param {ZipEntry|string} entry ZipEntry object or String with the full path of the entry
153
+ * @param {callback} callback
154
+ *
155
+ * @return Buffer or Null in case of error
156
+ */
157
+ readFileAsync: function (entry, callback) {
158
+ var item = getEntry(entry);
159
+ if (item) {
160
+ item.getDataAsync(callback);
161
+ } else {
162
+ callback(null, "getEntry failed for:" + entry);
163
+ }
164
+ },
165
+
166
+ /**
167
+ * Extracts the given entry from the archive and returns the content as plain text in the given encoding
168
+ * @param {ZipEntry|string} entry - ZipEntry object or String with the full path of the entry
169
+ * @param {string} encoding - Optional. If no encoding is specified utf8 is used
170
+ *
171
+ * @return String
172
+ */
173
+ readAsText: function (entry, encoding) {
174
+ var item = getEntry(entry);
175
+ if (item) {
176
+ var data = item.getData();
177
+ if (data && data.length) {
178
+ return data.toString(encoding || "utf8");
179
+ }
180
+ }
181
+ return "";
182
+ },
183
+
184
+ /**
185
+ * Asynchronous readAsText
186
+ * @param {ZipEntry|string} entry ZipEntry object or String with the full path of the entry
187
+ * @param {callback} callback
188
+ * @param {string} [encoding] - Optional. If no encoding is specified utf8 is used
189
+ *
190
+ * @return String
191
+ */
192
+ readAsTextAsync: function (entry, callback, encoding) {
193
+ var item = getEntry(entry);
194
+ if (item) {
195
+ item.getDataAsync(function (data, err) {
196
+ if (err) {
197
+ callback(data, err);
198
+ return;
199
+ }
200
+
201
+ if (data && data.length) {
202
+ callback(data.toString(encoding || "utf8"));
203
+ } else {
204
+ callback("");
205
+ }
206
+ });
207
+ } else {
208
+ callback("");
209
+ }
210
+ },
211
+
212
+ /**
213
+ * Remove the entry from the file or the entry and all it's nested directories and files if the given entry is a directory
214
+ *
215
+ * @param {ZipEntry|string} entry
216
+ * @param {boolean} withsubfolders
217
+ * @returns {void}
218
+ */
219
+ deleteFile: function (entry, withsubfolders = true) {
220
+ // @TODO: test deleteFile
221
+ var item = getEntry(entry);
222
+ if (item) {
223
+ _zip.deleteFile(item.entryName, withsubfolders);
224
+ }
225
+ },
226
+
227
+ /**
228
+ * Remove the entry from the file or directory without affecting any nested entries
229
+ *
230
+ * @param {ZipEntry|string} entry
231
+ * @returns {void}
232
+ */
233
+ deleteEntry: function (entry) {
234
+ // @TODO: test deleteEntry
235
+ var item = getEntry(entry);
236
+ if (item) {
237
+ _zip.deleteEntry(item.entryName);
238
+ }
239
+ },
240
+
241
+ /**
242
+ * Adds a comment to the zip. The zip must be rewritten after adding the comment.
243
+ *
244
+ * @param {string} comment
245
+ */
246
+ addZipComment: function (comment) {
247
+ // @TODO: test addZipComment
248
+ _zip.comment = comment;
249
+ },
250
+
251
+ /**
252
+ * Returns the zip comment
253
+ *
254
+ * @return String
255
+ */
256
+ getZipComment: function () {
257
+ return _zip.comment || "";
258
+ },
259
+
260
+ /**
261
+ * Adds a comment to a specified zipEntry. The zip must be rewritten after adding the comment
262
+ * The comment cannot exceed 65535 characters in length
263
+ *
264
+ * @param {ZipEntry} entry
265
+ * @param {string} comment
266
+ */
267
+ addZipEntryComment: function (entry, comment) {
268
+ var item = getEntry(entry);
269
+ if (item) {
270
+ item.comment = comment;
271
+ }
272
+ },
273
+
274
+ /**
275
+ * Returns the comment of the specified entry
276
+ *
277
+ * @param {ZipEntry} entry
278
+ * @return String
279
+ */
280
+ getZipEntryComment: function (entry) {
281
+ var item = getEntry(entry);
282
+ if (item) {
283
+ return item.comment || "";
284
+ }
285
+ return "";
286
+ },
287
+
288
+ /**
289
+ * Updates the content of an existing entry inside the archive. The zip must be rewritten after updating the content
290
+ *
291
+ * @param {ZipEntry} entry
292
+ * @param {Buffer} content
293
+ */
294
+ updateFile: function (entry, content) {
295
+ var item = getEntry(entry);
296
+ if (item) {
297
+ item.setData(content);
298
+ }
299
+ },
300
+
301
+ /**
302
+ * Adds a file from the disk to the archive
303
+ *
304
+ * @param {string} localPath File to add to zip
305
+ * @param {string} [zipPath] Optional path inside the zip
306
+ * @param {string} [zipName] Optional name for the file
307
+ * @param {string} [comment] Optional file comment
308
+ */
309
+ addLocalFile: function (localPath, zipPath, zipName, comment) {
310
+ if (filetools.fs.existsSync(localPath)) {
311
+ // fix ZipPath
312
+ zipPath = zipPath ? fixPath(zipPath) : "";
313
+
314
+ // p - local file name
315
+ const p = pth.win32.basename(pth.win32.normalize(localPath));
316
+
317
+ // add file name into zippath
318
+ zipPath += zipName ? zipName : p;
319
+
320
+ // read file attributes
321
+ const _attr = filetools.fs.statSync(localPath);
322
+
323
+ // get file content
324
+ const data = _attr.isFile() ? filetools.fs.readFileSync(localPath) : Buffer.alloc(0);
325
+
326
+ // if folder
327
+ if (_attr.isDirectory()) zipPath += filetools.sep;
328
+
329
+ // add file into zip file
330
+ this.addFile(zipPath, data, comment, _attr);
331
+ } else {
332
+ throw Utils.Errors.FILE_NOT_FOUND(localPath);
333
+ }
334
+ },
335
+
336
+ /**
337
+ * Callback for showing if everything was done.
338
+ *
339
+ * @callback doneCallback
340
+ * @param {Error} err - Error object
341
+ * @param {boolean} done - was request fully completed
342
+ */
343
+
344
+ /**
345
+ * Adds a file from the disk to the archive
346
+ *
347
+ * @param {(object|string)} options - options object, if it is string it us used as localPath.
348
+ * @param {string} options.localPath - Local path to the file.
349
+ * @param {string} [options.comment] - Optional file comment.
350
+ * @param {string} [options.zipPath] - Optional path inside the zip
351
+ * @param {string} [options.zipName] - Optional name for the file
352
+ * @param {doneCallback} callback - The callback that handles the response.
353
+ */
354
+ addLocalFileAsync: function (options, callback) {
355
+ options = typeof options === "object" ? options : { localPath: options };
356
+ const localPath = pth.resolve(options.localPath);
357
+ const { comment } = options;
358
+ let { zipPath, zipName } = options;
359
+ const self = this;
360
+
361
+ filetools.fs.stat(localPath, function (err, stats) {
362
+ if (err) return callback(err, false);
363
+ // fix ZipPath
364
+ zipPath = zipPath ? fixPath(zipPath) : "";
365
+ // p - local file name
366
+ const p = pth.win32.basename(pth.win32.normalize(localPath));
367
+ // add file name into zippath
368
+ zipPath += zipName ? zipName : p;
369
+
370
+ if (stats.isFile()) {
371
+ filetools.fs.readFile(localPath, function (err, data) {
372
+ if (err) return callback(err, false);
373
+ self.addFile(zipPath, data, comment, stats);
374
+ return setImmediate(callback, undefined, true);
375
+ });
376
+ } else if (stats.isDirectory()) {
377
+ zipPath += filetools.sep;
378
+ self.addFile(zipPath, Buffer.alloc(0), comment, stats);
379
+ return setImmediate(callback, undefined, true);
380
+ }
381
+ });
382
+ },
383
+
384
+ /**
385
+ * Adds a local directory and all its nested files and directories to the archive
386
+ *
387
+ * @param {string} localPath - local path to the folder
388
+ * @param {string} [zipPath] - optional path inside zip
389
+ * @param {(RegExp|function)} [filter] - optional RegExp or Function if files match will be included.
390
+ */
391
+ addLocalFolder: function (localPath, zipPath, filter) {
392
+ // Prepare filter
393
+ filter = filenameFilter(filter);
394
+
395
+ // fix ZipPath
396
+ zipPath = zipPath ? fixPath(zipPath) : "";
397
+
398
+ // normalize the path first
399
+ localPath = pth.normalize(localPath);
400
+
401
+ if (filetools.fs.existsSync(localPath)) {
402
+ const items = filetools.findFiles(localPath);
403
+ const self = this;
404
+
405
+ if (items.length) {
406
+ for (const filepath of items) {
407
+ const p = pth.join(zipPath, relativePath(localPath, filepath));
408
+ if (filter(p)) {
409
+ self.addLocalFile(filepath, pth.dirname(p));
410
+ }
411
+ }
412
+ }
413
+ } else {
414
+ throw Utils.Errors.FILE_NOT_FOUND(localPath);
415
+ }
416
+ },
417
+
418
+ /**
419
+ * Asynchronous addLocalFolder
420
+ * @param {string} localPath
421
+ * @param {callback} callback
422
+ * @param {string} [zipPath] optional path inside zip
423
+ * @param {RegExp|function} [filter] optional RegExp or Function if files match will
424
+ * be included.
425
+ */
426
+ addLocalFolderAsync: function (localPath, callback, zipPath, filter) {
427
+ // Prepare filter
428
+ filter = filenameFilter(filter);
429
+
430
+ // fix ZipPath
431
+ zipPath = zipPath ? fixPath(zipPath) : "";
432
+
433
+ // normalize the path first
434
+ localPath = pth.normalize(localPath);
435
+
436
+ var self = this;
437
+ filetools.fs.open(localPath, "r", function (err) {
438
+ if (err && err.code === "ENOENT") {
439
+ callback(undefined, Utils.Errors.FILE_NOT_FOUND(localPath));
440
+ } else if (err) {
441
+ callback(undefined, err);
442
+ } else {
443
+ var items = filetools.findFiles(localPath);
444
+ var i = -1;
445
+
446
+ var next = function () {
447
+ i += 1;
448
+ if (i < items.length) {
449
+ var filepath = items[i];
450
+ var p = relativePath(localPath, filepath).split("\\").join("/"); //windows fix
451
+ p = p
452
+ .normalize("NFD")
453
+ .replace(/[\u0300-\u036f]/g, "")
454
+ .replace(/[^\x20-\x7E]/g, ""); // accent fix
455
+ if (filter(p)) {
456
+ filetools.fs.stat(filepath, function (er0, stats) {
457
+ if (er0) callback(undefined, er0);
458
+ if (stats.isFile()) {
459
+ filetools.fs.readFile(filepath, function (er1, data) {
460
+ if (er1) {
461
+ callback(undefined, er1);
462
+ } else {
463
+ self.addFile(zipPath + p, data, "", stats);
464
+ next();
465
+ }
466
+ });
467
+ } else {
468
+ self.addFile(zipPath + p + "/", Buffer.alloc(0), "", stats);
469
+ next();
470
+ }
471
+ });
472
+ } else {
473
+ process.nextTick(() => {
474
+ next();
475
+ });
476
+ }
477
+ } else {
478
+ callback(true, undefined);
479
+ }
480
+ };
481
+
482
+ next();
483
+ }
484
+ });
485
+ },
486
+
487
+ /**
488
+ * Adds a local directory and all its nested files and directories to the archive
489
+ *
490
+ * @param {object | string} options - options object, if it is string it us used as localPath.
491
+ * @param {string} options.localPath - Local path to the folder.
492
+ * @param {string} [options.zipPath] - optional path inside zip.
493
+ * @param {RegExp|function} [options.filter] - optional RegExp or Function if files match will be included.
494
+ * @param {function|string} [options.namefix] - optional function to help fix filename
495
+ * @param {doneCallback} callback - The callback that handles the response.
496
+ *
497
+ */
498
+ addLocalFolderAsync2: function (options, callback) {
499
+ const self = this;
500
+ options = typeof options === "object" ? options : { localPath: options };
501
+ // Resolve the local filesystem path with the platform resolver. Do NOT
502
+ // run it through fixPath: that normalizes ZIP-internal paths to POSIX
503
+ // and prepends "/", which turns a Windows path like C:\dir into
504
+ // \C:\dir, so readdir finds nothing and the archive comes out empty.
505
+ const localPath = pth.resolve(options.localPath);
506
+ let { zipPath, filter, namefix } = options;
507
+
508
+ if (filter instanceof RegExp) {
509
+ filter = (function (rx) {
510
+ return function (filename) {
511
+ return rx.test(filename);
512
+ };
513
+ })(filter);
514
+ } else if ("function" !== typeof filter) {
515
+ filter = function () {
516
+ return true;
517
+ };
518
+ }
519
+
520
+ // fix ZipPath
521
+ zipPath = zipPath ? fixPath(zipPath) : "";
522
+
523
+ // Check Namefix function
524
+ if (namefix === "latin1") {
525
+ namefix = (str) =>
526
+ str
527
+ .normalize("NFD")
528
+ .replace(/[\u0300-\u036f]/g, "")
529
+ .replace(/[^\x20-\x7E]/g, ""); // accent fix (latin1 characers only)
530
+ }
531
+
532
+ if (typeof namefix !== "function") namefix = (str) => str;
533
+
534
+ // internal, create relative path + fix the name
535
+ const relPathFix = (entry) => pth.join(zipPath, namefix(relativePath(localPath, entry)));
536
+ const fileNameFix = (entry) => pth.win32.basename(pth.win32.normalize(namefix(entry)));
537
+
538
+ filetools.fs.open(localPath, "r", function (err) {
539
+ if (err && err.code === "ENOENT") {
540
+ // callback is (err, done); errors belong in the first argument,
541
+ // otherwise addLocalFolderPromise treats the error as "done" and
542
+ // resolves instead of rejecting.
543
+ callback(Utils.Errors.FILE_NOT_FOUND(localPath), false);
544
+ } else if (err) {
545
+ callback(err, false);
546
+ } else {
547
+ filetools.findFilesAsync(localPath, function (err, fileEntries) {
548
+ if (err) return callback(err, false);
549
+ fileEntries = fileEntries.filter((dir) => filter(relPathFix(dir)));
550
+ // Nothing to add (empty folder or everything filtered out) is a
551
+ // success, not an error. Report done and stop, otherwise the
552
+ // reduce below runs and the callback fires a second time -- and
553
+ // signalling done=false left addLocalFolderPromise hanging.
554
+ if (!fileEntries.length) return callback(undefined, true);
555
+
556
+ setImmediate(
557
+ fileEntries.reverse().reduce(function (next, entry) {
558
+ return function (err, done) {
559
+ if (err || done === false) return setImmediate(next, err, false);
560
+
561
+ self.addLocalFileAsync(
562
+ {
563
+ localPath: entry,
564
+ zipPath: pth.dirname(relPathFix(entry)),
565
+ zipName: fileNameFix(entry)
566
+ },
567
+ next
568
+ );
569
+ };
570
+ }, callback)
571
+ );
572
+ });
573
+ }
574
+ });
575
+ },
576
+
577
+ /**
578
+ * Adds a local directory and all its nested files and directories to the archive
579
+ *
580
+ * @param {string} localPath - path where files will be extracted
581
+ * @param {object} props - optional properties
582
+ * @param {string} [props.zipPath] - optional path inside zip
583
+ * @param {RegExp|function} [props.filter] - optional RegExp or Function if files match will be included.
584
+ * @param {function|string} [props.namefix] - optional function to help fix filename
585
+ */
586
+ addLocalFolderPromise: function (localPath, props) {
587
+ return new Promise((resolve, reject) => {
588
+ this.addLocalFolderAsync2(Object.assign({ localPath }, props), (err, done) => {
589
+ if (err) return reject(err);
590
+ if (done) resolve(this);
591
+ });
592
+ });
593
+ },
594
+
595
+ /**
596
+ * Allows you to create a entry (file or directory) in the zip file.
597
+ * If you want to create a directory the entryName must end in / and a null buffer should be provided.
598
+ * Comment and attributes are optional
599
+ *
600
+ * @param {string} entryName
601
+ * @param {Buffer | string} content - file content as buffer or utf8 coded string
602
+ * @param {string} [comment] - file comment
603
+ * @param {number | object} [attr] - number as unix file permissions, object as filesystem Stats object
604
+ */
605
+ addFile: function (entryName, content, comment, attr) {
606
+ entryName = zipnamefix(entryName);
607
+ let entry = getEntry(entryName);
608
+ const update = entry != null;
609
+
610
+ // prepare new entry
611
+ if (!update) {
612
+ entry = new ZipEntry(opts);
613
+ entry.entryName = entryName;
614
+ }
615
+ entry.comment = comment || "";
616
+
617
+ const isStat = "object" === typeof attr && attr instanceof filetools.fs.Stats;
618
+
619
+ // last modification time from file stats
620
+ if (isStat) {
621
+ entry.header.time = attr.mtime;
622
+ }
623
+
624
+ // Set file attribute
625
+ var fileattr = entry.isDirectory ? 0x10 : 0; // (MS-DOS directory flag)
626
+
627
+ // extended attributes field for Unix
628
+ // set file type either S_IFDIR / S_IFREG
629
+ let unix = entry.isDirectory ? 0x4000 : 0x8000;
630
+
631
+ if (isStat) {
632
+ // File attributes from file stats
633
+ unix |= 0xfff & attr.mode;
634
+ } else if ("number" === typeof attr) {
635
+ // attr from given attr values
636
+ unix |= 0xfff & attr;
637
+ } else {
638
+ // Default values:
639
+ unix |= entry.isDirectory ? 0o755 : 0o644; // permissions (drwxr-xr-x) or (-r-wr--r--)
640
+ }
641
+
642
+ fileattr = (fileattr | (unix << 16)) >>> 0; // add attributes
643
+
644
+ entry.attr = fileattr;
645
+
646
+ entry.setData(content);
647
+ if (!update) _zip.setEntry(entry);
648
+
649
+ return entry;
650
+ },
651
+
652
+ /**
653
+ * Returns an array of ZipEntry objects representing the files and folders inside the archive
654
+ *
655
+ * @param {string} [password]
656
+ * @returns Array
657
+ */
658
+ getEntries: function (password) {
659
+ _zip.password = password;
660
+ return _zip ? _zip.entries : [];
661
+ },
662
+
663
+ /**
664
+ * Returns a ZipEntry object representing the file or folder specified by ``name``.
665
+ *
666
+ * @param {string} name
667
+ * @return ZipEntry
668
+ */
669
+ getEntry: function (/**String*/ name) {
670
+ return getEntry(name);
671
+ },
672
+
673
+ getEntryCount: function () {
674
+ return _zip.getEntryCount();
675
+ },
676
+
677
+ forEach: function (callback) {
678
+ return _zip.forEach(callback);
679
+ },
680
+
681
+ /**
682
+ * Extracts the given entry to the given targetPath
683
+ * If the entry is a directory inside the archive, the entire directory and it's subdirectories will be extracted
684
+ *
685
+ * @param {string|ZipEntry} entry - ZipEntry object or String with the full path of the entry
686
+ * @param {string} targetPath - Target folder where to write the file
687
+ * @param {boolean} [maintainEntryPath=true] - If maintainEntryPath is true and the entry is inside a folder, the entry folder will be created in targetPath as well. Default is TRUE
688
+ * @param {boolean} [overwrite=false] - If the file already exists at the target path, the file will be overwriten if this is true.
689
+ * @param {boolean} [keepOriginalPermission=false] - The file will be set as the permission from the entry if this is true.
690
+ * @param {string} [outFileName] - String If set will override the filename of the extracted file (Only works if the entry is a file)
691
+ *
692
+ * @return Boolean
693
+ */
694
+ extractEntryTo: function (entry, targetPath, maintainEntryPath, overwrite, keepOriginalPermission, outFileName) {
695
+ overwrite = get_Bool(false, overwrite);
696
+ keepOriginalPermission = get_Bool(false, keepOriginalPermission);
697
+ maintainEntryPath = get_Bool(true, maintainEntryPath);
698
+ outFileName = get_Str(keepOriginalPermission, outFileName);
699
+
700
+ var item = getEntry(entry);
701
+ if (!item) {
702
+ throw Utils.Errors.NO_ENTRY();
703
+ }
704
+
705
+ var entryName = canonical(item.entryName);
706
+
707
+ var target = sanitize(targetPath, outFileName && !item.isDirectory ? canonical(outFileName) : maintainEntryPath ? entryName : pth.basename(entryName));
708
+
709
+ if (item.isDirectory) {
710
+ var children = _zip.getEntryChildren(item);
711
+ children.forEach(function (child) {
712
+ if (child.isDirectory) return;
713
+ var content = child.getData();
714
+ if (!content) {
715
+ throw Utils.Errors.CANT_EXTRACT_FILE();
716
+ }
717
+ // When not maintaining the full entry path, keep each child's path
718
+ // relative to the extracted directory (drop the directory's own
719
+ // prefix) instead of flattening every file to its basename, which
720
+ // collapsed subdirectories together (issue #306).
721
+ var name = canonical(maintainEntryPath ? child.entryName : child.entryName.substring(item.entryName.length));
722
+ var childName = sanitize(targetPath, name);
723
+ // reject writing through a pre-existing symlink inside the target
724
+ filetools.assertPathSafe(targetPath, childName);
725
+ // The reverse operation for attr depend on method addFile()
726
+ const fileAttr = keepOriginalPermission ? child.header.fileAttr : undefined;
727
+ filetools.writeFileTo(childName, content, overwrite, fileAttr);
728
+ });
729
+ return true;
730
+ }
731
+
732
+ var content = item.getData(_zip.password);
733
+ if (!content) throw Utils.Errors.CANT_EXTRACT_FILE();
734
+
735
+ // reject writing through a pre-existing symlink inside the target
736
+ filetools.assertPathSafe(targetPath, target);
737
+
738
+ if (filetools.fs.existsSync(target) && !overwrite) {
739
+ throw Utils.Errors.CANT_OVERRIDE();
740
+ }
741
+ // The reverse operation for attr depend on method addFile()
742
+ const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
743
+ filetools.writeFileTo(target, content, overwrite, fileAttr);
744
+
745
+ return true;
746
+ },
747
+
748
+ /**
749
+ * Test the archive
750
+ * @param {string} [pass]
751
+ */
752
+ test: function (pass) {
753
+ if (!_zip) {
754
+ return false;
755
+ }
756
+
757
+ for (var entry of _zip.entries) {
758
+ try {
759
+ if (entry.isDirectory) {
760
+ continue;
761
+ }
762
+ // was `_zip.entries[entry]` (indexing the array with an entry
763
+ // object -> undefined -> threw -> test() always returned false)
764
+ var content = entry.getData(pass);
765
+ if (!content) {
766
+ return false;
767
+ }
768
+ } catch (err) {
769
+ return false;
770
+ }
771
+ }
772
+ return true;
773
+ },
774
+
775
+ /**
776
+ * Extracts the entire archive to the given location
777
+ *
778
+ * @param {string} targetPath Target location
779
+ * @param {boolean} [overwrite=false] If the file already exists at the target path, the file will be overwriten if this is true.
780
+ * Default is FALSE
781
+ * @param {boolean} [keepOriginalPermission=false] The file will be set as the permission from the entry if this is true.
782
+ * Default is FALSE
783
+ * @param {string|Buffer} [pass] password
784
+ */
785
+ extractAllTo: function (targetPath, overwrite, keepOriginalPermission, pass) {
786
+ keepOriginalPermission = get_Bool(false, keepOriginalPermission);
787
+ pass = get_Str(keepOriginalPermission, pass);
788
+ overwrite = get_Bool(false, overwrite);
789
+ if (!_zip) throw Utils.Errors.NO_ZIP();
790
+
791
+ const dirEntries = [];
792
+ _zip.entries.forEach(function (entry) {
793
+ var entryName = sanitize(targetPath, canonical(entry.entryName));
794
+ // reject writing through a pre-existing symlink inside the target
795
+ filetools.assertPathSafe(targetPath, entryName);
796
+ if (entry.isDirectory) {
797
+ filetools.makeDir(entryName);
798
+ // defer restoring the directory permission until its files are written
799
+ if (keepOriginalPermission) dirEntries.push({ path: entryName, attr: entry.header.fileAttr });
800
+ return;
801
+ }
802
+ var content = entry.getData(pass);
803
+ if (!content) {
804
+ throw Utils.Errors.CANT_EXTRACT_FILE();
805
+ }
806
+ // The reverse operation for attr depend on method addFile()
807
+ const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
808
+ filetools.writeFileTo(entryName, content, overwrite, fileAttr);
809
+ try {
810
+ // best-effort: an invalid date in the archive or a filesystem that
811
+ // rejects utimes must not fail extraction of already-written content (issue #379)
812
+ filetools.fs.utimesSync(entryName, entry.header.time, entry.header.time);
813
+ } catch (err) {
814
+ /* ignore timestamp failures */
815
+ }
816
+ });
817
+
818
+ applyDirAttributes(dirEntries);
819
+ },
820
+
821
+ /**
822
+ * Asynchronous extractAllTo
823
+ *
824
+ * @param {string} targetPath Target location
825
+ * @param {boolean} [overwrite=false] If the file already exists at the target path, the file will be overwriten if this is true.
826
+ * Default is FALSE
827
+ * @param {boolean} [keepOriginalPermission=false] The file will be set as the permission from the entry if this is true.
828
+ * Default is FALSE
829
+ * @param {function} callback The callback will be executed when all entries are extracted successfully or any error is thrown.
830
+ */
831
+ extractAllToAsync: function (targetPath, overwrite, keepOriginalPermission, callback) {
832
+ callback = get_Fun(overwrite, keepOriginalPermission, callback);
833
+ keepOriginalPermission = get_Bool(false, keepOriginalPermission);
834
+ overwrite = get_Bool(false, overwrite);
835
+ if (!callback) {
836
+ return new Promise((resolve, reject) => {
837
+ this.extractAllToAsync(targetPath, overwrite, keepOriginalPermission, function (err) {
838
+ if (err) {
839
+ reject(err);
840
+ } else {
841
+ resolve(this);
842
+ }
843
+ });
844
+ });
845
+ }
846
+ if (!_zip) {
847
+ callback(Utils.Errors.NO_ZIP());
848
+ return;
849
+ }
850
+
851
+ targetPath = pth.resolve(targetPath);
852
+ // convert entryName to
853
+ const getPath = (entry) => sanitize(targetPath, pth.normalize(canonical(entry.entryName)));
854
+ const getError = (msg, file) => new Error(msg + ': "' + file + '"');
855
+
856
+ // separate directories from files
857
+ const dirEntries = [];
858
+ const fileEntries = [];
859
+ _zip.entries.forEach((e) => {
860
+ if (e.isDirectory) {
861
+ dirEntries.push(e);
862
+ } else {
863
+ fileEntries.push(e);
864
+ }
865
+ });
866
+
867
+ // Create directory entries first synchronously
868
+ // this prevents race condition and assures folders are there before writing files
869
+ const deferredDirAttr = [];
870
+ for (const entry of dirEntries) {
871
+ const dirPath = getPath(entry);
872
+ // The reverse operation for attr depend on method addFile()
873
+ const dirAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
874
+ try {
875
+ // reject writing through a pre-existing symlink inside the target
876
+ filetools.assertPathSafe(targetPath, dirPath);
877
+ filetools.makeDir(dirPath);
878
+ } catch (er) {
879
+ callback(getError("Unable to create folder", dirPath));
880
+ continue;
881
+ }
882
+ // defer restoring the directory permission until its files are written:
883
+ // a restrictive mode applied now would block writing them
884
+ if (dirAttr) deferredDirAttr.push({ path: dirPath, attr: dirAttr });
885
+ try {
886
+ // in unix timestamp will change if files are later added to folder, but still.
887
+ // best-effort: a utimes failure must not abort extraction (issue #379)
888
+ filetools.fs.utimesSync(dirPath, entry.header.time, entry.header.time);
889
+ } catch (er) {
890
+ /* ignore timestamp failures */
891
+ }
892
+ }
893
+
894
+ // restore directory permissions once every file has been extracted
895
+ const done = (err) => {
896
+ if (!err) {
897
+ try {
898
+ applyDirAttributes(deferredDirAttr);
899
+ } catch (er) {
900
+ return callback(getError("Unable to set folder permissions", er.path || ""));
901
+ }
902
+ }
903
+ callback(err);
904
+ };
905
+
906
+ fileEntries.reverse().reduce(function (next, entry) {
907
+ return function (err) {
908
+ if (err) {
909
+ next(err);
910
+ } else {
911
+ const entryName = pth.normalize(canonical(entry.entryName));
912
+ const filePath = sanitize(targetPath, entryName);
913
+ try {
914
+ // reject writing through a pre-existing symlink inside the target
915
+ filetools.assertPathSafe(targetPath, filePath);
916
+ } catch (er) {
917
+ return next(er);
918
+ }
919
+ entry.getDataAsync(function (content, err_1) {
920
+ if (err_1) {
921
+ next(err_1);
922
+ } else if (!content) {
923
+ next(Utils.Errors.CANT_EXTRACT_FILE());
924
+ } else {
925
+ // The reverse operation for attr depend on method addFile()
926
+ const fileAttr = keepOriginalPermission ? entry.header.fileAttr : undefined;
927
+ filetools.writeFileToAsync(filePath, content, overwrite, fileAttr, function (succ) {
928
+ if (!succ) {
929
+ return next(getError("Unable to write file", filePath));
930
+ }
931
+ filetools.fs.utimes(filePath, entry.header.time, entry.header.time, function () {
932
+ // best-effort: a utimes failure must not abort extraction
933
+ // of already-written content (issue #379)
934
+ next();
935
+ });
936
+ });
937
+ }
938
+ });
939
+ }
940
+ };
941
+ }, done)();
942
+ },
943
+
944
+ /**
945
+ * Writes the newly created zip file to disk at the specified location or if a zip was opened and no ``targetFileName`` is provided, it will overwrite the opened zip
946
+ *
947
+ * @param {string} targetFileName
948
+ * @param {function} callback
949
+ */
950
+ writeZip: function (targetFileName, callback) {
951
+ if (arguments.length === 1) {
952
+ if (typeof targetFileName === "function") {
953
+ callback = targetFileName;
954
+ targetFileName = "";
955
+ }
956
+ }
957
+
958
+ if (!targetFileName && opts.filename) {
959
+ targetFileName = opts.filename;
960
+ }
961
+ if (!targetFileName) return;
962
+
963
+ var zipData = _zip.compressToBuffer();
964
+ if (zipData) {
965
+ var ok = filetools.writeFileTo(targetFileName, zipData, true);
966
+ if (typeof callback === "function") callback(!ok ? new Error("failed") : null, "");
967
+ }
968
+ },
969
+
970
+ /**
971
+ *
972
+ * @param {string} targetFileName
973
+ * @param {object} [props]
974
+ * @param {boolean} [props.overwrite=true] If the file already exists at the target path, the file will be overwriten if this is true.
975
+ * @param {boolean} [props.perm] The file will be set as the permission from the entry if this is true.
976
+
977
+ * @returns {Promise<void>}
978
+ */
979
+ writeZipPromise: function (/**String*/ targetFileName, /* object */ props) {
980
+ const { overwrite, perm } = Object.assign({ overwrite: true }, props);
981
+
982
+ return new Promise((resolve, reject) => {
983
+ // find file name
984
+ if (!targetFileName && opts.filename) targetFileName = opts.filename;
985
+ if (!targetFileName) reject("ADM-ZIP: ZIP File Name Missing");
986
+
987
+ this.toBufferPromise().then((zipData) => {
988
+ const ret = (done) => (done ? resolve(done) : reject("ADM-ZIP: Wasn't able to write zip file"));
989
+ filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
990
+ }, reject);
991
+ });
992
+ },
993
+
994
+ /**
995
+ * @returns {Promise<Buffer>} A promise to the Buffer.
996
+ */
997
+ toBufferPromise: function () {
998
+ return new Promise((resolve, reject) => {
999
+ _zip.toAsyncBuffer(resolve, reject);
1000
+ });
1001
+ },
1002
+
1003
+ /**
1004
+ * Returns the content of the entire zip file as a Buffer object
1005
+ *
1006
+ * @prop {function} [onSuccess]
1007
+ * @prop {function} [onFail]
1008
+ * @prop {function} [onItemStart]
1009
+ * @prop {function} [onItemEnd]
1010
+ * @returns {Buffer}
1011
+ */
1012
+ toBuffer: function (onSuccess, onFail, onItemStart, onItemEnd) {
1013
+ if (typeof onSuccess === "function") {
1014
+ _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
1015
+ return null;
1016
+ }
1017
+ return _zip.compressToBuffer();
1018
+ }
1019
+ };
1020
+ };