1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, '__esModule', { value: true });
|
4 |
|
5 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
6 |
|
7 | var utilNpm = require('@pagedip/util-npm');
|
8 | var resolve = require('@pagedip/util-resolve');
|
9 | var resolve__default = _interopDefault(resolve);
|
10 |
|
11 | var asyncGenerator = function () {
|
12 | function AwaitValue(value) {
|
13 | this.value = value;
|
14 | }
|
15 |
|
16 | function AsyncGenerator(gen) {
|
17 | var front, back;
|
18 |
|
19 | function send(key, arg) {
|
20 | return new Promise(function (resolve$$1, reject) {
|
21 | var request = {
|
22 | key: key,
|
23 | arg: arg,
|
24 | resolve: resolve$$1,
|
25 | reject: reject,
|
26 | next: null
|
27 | };
|
28 |
|
29 | if (back) {
|
30 | back = back.next = request;
|
31 | } else {
|
32 | front = back = request;
|
33 | resume(key, arg);
|
34 | }
|
35 | });
|
36 | }
|
37 |
|
38 | function resume(key, arg) {
|
39 | try {
|
40 | var result = gen[key](arg);
|
41 | var value = result.value;
|
42 |
|
43 | if (value instanceof AwaitValue) {
|
44 | Promise.resolve(value.value).then(function (arg) {
|
45 | resume("next", arg);
|
46 | }, function (arg) {
|
47 | resume("throw", arg);
|
48 | });
|
49 | } else {
|
50 | settle(result.done ? "return" : "normal", result.value);
|
51 | }
|
52 | } catch (err) {
|
53 | settle("throw", err);
|
54 | }
|
55 | }
|
56 |
|
57 | function settle(type, value) {
|
58 | switch (type) {
|
59 | case "return":
|
60 | front.resolve({
|
61 | value: value,
|
62 | done: true
|
63 | });
|
64 | break;
|
65 |
|
66 | case "throw":
|
67 | front.reject(value);
|
68 | break;
|
69 |
|
70 | default:
|
71 | front.resolve({
|
72 | value: value,
|
73 | done: false
|
74 | });
|
75 | break;
|
76 | }
|
77 |
|
78 | front = front.next;
|
79 |
|
80 | if (front) {
|
81 | resume(front.key, front.arg);
|
82 | } else {
|
83 | back = null;
|
84 | }
|
85 | }
|
86 |
|
87 | this._invoke = send;
|
88 |
|
89 | if (typeof gen.return !== "function") {
|
90 | this.return = undefined;
|
91 | }
|
92 | }
|
93 |
|
94 | if (typeof Symbol === "function" && Symbol.asyncIterator) {
|
95 | AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
|
96 | return this;
|
97 | };
|
98 | }
|
99 |
|
100 | AsyncGenerator.prototype.next = function (arg) {
|
101 | return this._invoke("next", arg);
|
102 | };
|
103 |
|
104 | AsyncGenerator.prototype.throw = function (arg) {
|
105 | return this._invoke("throw", arg);
|
106 | };
|
107 |
|
108 | AsyncGenerator.prototype.return = function (arg) {
|
109 | return this._invoke("return", arg);
|
110 | };
|
111 |
|
112 | return {
|
113 | wrap: function (fn) {
|
114 | return function () {
|
115 | return new AsyncGenerator(fn.apply(this, arguments));
|
116 | };
|
117 | },
|
118 | await: function (value) {
|
119 | return new AwaitValue(value);
|
120 | }
|
121 | };
|
122 | }();
|
123 |
|
124 |
|
125 |
|
126 | var asyncToGenerator = function (fn) {
|
127 | return function () {
|
128 | var gen = fn.apply(this, arguments);
|
129 | return new Promise(function (resolve$$1, reject) {
|
130 | function step(key, arg) {
|
131 | try {
|
132 | var info = gen[key](arg);
|
133 | var value = info.value;
|
134 | } catch (error) {
|
135 | reject(error);
|
136 | return;
|
137 | }
|
138 |
|
139 | if (info.done) {
|
140 | resolve$$1(value);
|
141 | } else {
|
142 | return Promise.resolve(value).then(function (value) {
|
143 | step("next", value);
|
144 | }, function (err) {
|
145 | step("throw", err);
|
146 | });
|
147 | }
|
148 | }
|
149 |
|
150 | return step("next");
|
151 | });
|
152 | };
|
153 | };
|
154 |
|
155 |
|
156 |
|
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 |
|
163 |
|
164 |
|
165 | var _extends = Object.assign || function (target) {
|
166 | for (var i = 1; i < arguments.length; i++) {
|
167 | var source = arguments[i];
|
168 |
|
169 | for (var key in source) {
|
170 | if (Object.prototype.hasOwnProperty.call(source, key)) {
|
171 | target[key] = source[key];
|
172 | }
|
173 | }
|
174 | }
|
175 |
|
176 | return target;
|
177 | };
|
178 |
|
179 | function formatPackageName(pkg) {
|
180 | if (typeof pkg !== "string" || !pkg) {
|
181 | throw new Error("Expecting non-empty string for package name.");
|
182 | }
|
183 |
|
184 | if (!resolve.isPath.test(pkg) && pkg.substr(0, 9) !== "@pagedip/") {
|
185 | pkg = "@pagedip/" + pkg;
|
186 | }
|
187 |
|
188 | return pkg;
|
189 | }
|
190 |
|
191 | var install = (function () {
|
192 | var _ref = asyncToGenerator(function* (pkgs, opts) {
|
193 | if (!Array.isArray(pkgs)) pkgs = pkgs == null ? [] : [pkgs];
|
194 |
|
195 | opts = opts || {};
|
196 | pkgs = pkgs.map(formatPackageName);
|
197 |
|
198 | if (opts.tag) {
|
199 | pkgs = pkgs.map(function (p) {
|
200 | return p + "@" + opts.tag;
|
201 | });
|
202 | }
|
203 |
|
204 | if (opts.logger) opts.logger.debug("Installing packages '%s'", pkgs);
|
205 |
|
206 | yield utilNpm.npmInstall(pkgs.concat("-g"));
|
207 | });
|
208 |
|
209 | function install(_x, _x2) {
|
210 | return _ref.apply(this, arguments);
|
211 | }
|
212 |
|
213 | return install;
|
214 | })();
|
215 |
|
216 | var load = (function () {
|
217 | var _ref = asyncToGenerator(function* (pkgname, opts) {
|
218 | var cliFile = yield resolve__default(pkgname, _extends({}, opts, {
|
219 | leads: ["@pagedip/", ""],
|
220 | packageFilter: function packageFilter(pkg) {
|
221 | if (pkg.command) pkg.main = pkg.command;else delete pkg.main;
|
222 | return pkg;
|
223 | }
|
224 | }));
|
225 |
|
226 | if (!cliFile) {
|
227 | var err = new Error("Could not find package '" + pkgname + "'.");
|
228 | err.code = "MODULE_NOT_FOUND";
|
229 | throw err;
|
230 | }
|
231 |
|
232 | return require(cliFile);
|
233 | });
|
234 |
|
235 | function load(_x, _x2) {
|
236 | return _ref.apply(this, arguments);
|
237 | }
|
238 |
|
239 | return load;
|
240 | })();
|
241 |
|
242 | exports.install = install;
|
243 | exports.load = load;
|