1 | Function.prototype.$asyncbind = function $asyncbind(self, catcher) {
|
2 | "use strict";
|
3 |
|
4 | if (!Function.prototype.$asyncbind) {
|
5 | Object.defineProperty(Function.prototype, "$asyncbind", {
|
6 | value: $asyncbind,
|
7 | enumerable: false,
|
8 | configurable: true,
|
9 | writable: true
|
10 | });
|
11 | }
|
12 |
|
13 | if (!$asyncbind.trampoline) {
|
14 | $asyncbind.trampoline = function trampoline(t, x, s, e, u) {
|
15 | return function b(q) {
|
16 | while (q) {
|
17 | if (q.then) {
|
18 | q = q.then(b, e);
|
19 | return u ? undefined : q;
|
20 | }
|
21 |
|
22 | try {
|
23 | if (q.pop) {
|
24 | if (q.length) return q.pop() ? x.call(t) : q;
|
25 | q = s;
|
26 | } else q = q.call(t);
|
27 | } catch (r) {
|
28 | return e(r);
|
29 | }
|
30 | }
|
31 | };
|
32 | };
|
33 | }
|
34 |
|
35 | if (!$asyncbind.LazyThenable) {
|
36 | $asyncbind.LazyThenable = function () {
|
37 | function isThenable(obj) {
|
38 | return obj && obj instanceof Object && typeof obj.then === "function";
|
39 | }
|
40 |
|
41 | function resolution(p, r, how) {
|
42 | try {
|
43 | var x = how ? how(r) : r;
|
44 | if (p === x) return p.reject(new TypeError("Promise resolution loop"));
|
45 |
|
46 | if (isThenable(x)) {
|
47 | x.then(function (y) {
|
48 | resolution(p, y);
|
49 | }, function (e) {
|
50 | p.reject(e);
|
51 | });
|
52 | } else {
|
53 | p.resolve(x);
|
54 | }
|
55 | } catch (ex) {
|
56 | p.reject(ex);
|
57 | }
|
58 | }
|
59 |
|
60 | function Chained() {}
|
61 |
|
62 | ;
|
63 | Chained.prototype = {
|
64 | resolve: _unchained,
|
65 | reject: _unchained,
|
66 | then: thenChain
|
67 | };
|
68 |
|
69 | function _unchained(v) {}
|
70 |
|
71 | function thenChain(res, rej) {
|
72 | this.resolve = res;
|
73 | this.reject = rej;
|
74 | }
|
75 |
|
76 | function then(res, rej) {
|
77 | var chain = new Chained();
|
78 |
|
79 | try {
|
80 | this._resolver(function (value) {
|
81 | return isThenable(value) ? value.then(res, rej) : resolution(chain, value, res);
|
82 | }, function (ex) {
|
83 | resolution(chain, ex, rej);
|
84 | });
|
85 | } catch (ex) {
|
86 | resolution(chain, ex, rej);
|
87 | }
|
88 |
|
89 | return chain;
|
90 | }
|
91 |
|
92 | function Thenable(resolver) {
|
93 | this._resolver = resolver;
|
94 | this.then = then;
|
95 | }
|
96 |
|
97 | ;
|
98 |
|
99 | Thenable.resolve = function (v) {
|
100 | return Thenable.isThenable(v) ? v : {
|
101 | then: function then(resolve) {
|
102 | return resolve(v);
|
103 | }
|
104 | };
|
105 | };
|
106 |
|
107 | Thenable.isThenable = isThenable;
|
108 | return Thenable;
|
109 | }();
|
110 |
|
111 | $asyncbind.EagerThenable = $asyncbind.Thenable = ($asyncbind.EagerThenableFactory = function (tick) {
|
112 | tick = tick || typeof process === "object" && process.nextTick || typeof setImmediate === "function" && setImmediate || function (f) {
|
113 | setTimeout(f, 0);
|
114 | };
|
115 |
|
116 | var soon = function () {
|
117 | var fq = [],
|
118 | fqStart = 0,
|
119 | bufferSize = 1024;
|
120 |
|
121 | function callQueue() {
|
122 | while (fq.length - fqStart) {
|
123 | try {
|
124 | fq[fqStart]();
|
125 | } catch (ex) {}
|
126 |
|
127 | fq[fqStart++] = undefined;
|
128 |
|
129 | if (fqStart === bufferSize) {
|
130 | fq.splice(0, bufferSize);
|
131 | fqStart = 0;
|
132 | }
|
133 | }
|
134 | }
|
135 |
|
136 | return function (fn) {
|
137 | fq.push(fn);
|
138 | if (fq.length - fqStart === 1) tick(callQueue);
|
139 | };
|
140 | }();
|
141 |
|
142 | function Zousan(func) {
|
143 | if (func) {
|
144 | var me = this;
|
145 | func(function (arg) {
|
146 | me.resolve(arg);
|
147 | }, function (arg) {
|
148 | me.reject(arg);
|
149 | });
|
150 | }
|
151 | }
|
152 |
|
153 | Zousan.prototype = {
|
154 | resolve: function resolve(value) {
|
155 | if (this.state !== undefined) return;
|
156 | if (value === this) return this.reject(new TypeError("Attempt to resolve promise with self"));
|
157 | var me = this;
|
158 |
|
159 | if (value && (typeof value === "function" || typeof value === "object")) {
|
160 | try {
|
161 | var first = 0;
|
162 | var then = value.then;
|
163 |
|
164 | if (typeof then === "function") {
|
165 | then.call(value, function (ra) {
|
166 | if (!first++) {
|
167 | me.resolve(ra);
|
168 | }
|
169 | }, function (rr) {
|
170 | if (!first++) {
|
171 | me.reject(rr);
|
172 | }
|
173 | });
|
174 | return;
|
175 | }
|
176 | } catch (e) {
|
177 | if (!first) this.reject(e);
|
178 | return;
|
179 | }
|
180 | }
|
181 |
|
182 | this.state = STATE_FULFILLED;
|
183 | this.v = value;
|
184 | if (me.c) soon(function () {
|
185 | for (var n = 0, l = me.c.length; n < l; n++) STATE_FULFILLED(me.c[n], value);
|
186 | });
|
187 | },
|
188 | reject: function reject(reason) {
|
189 | if (this.state !== undefined) return;
|
190 | this.state = STATE_REJECTED;
|
191 | this.v = reason;
|
192 | var clients = this.c;
|
193 | if (clients) soon(function () {
|
194 | for (var n = 0, l = clients.length; n < l; n++) STATE_REJECTED(clients[n], reason);
|
195 | });
|
196 | },
|
197 | then: function then(onF, onR) {
|
198 | var p = new Zousan();
|
199 | var client = {
|
200 | y: onF,
|
201 | n: onR,
|
202 | p: p
|
203 | };
|
204 |
|
205 | if (this.state === undefined) {
|
206 | if (this.c) this.c.push(client);else this.c = [client];
|
207 | } else {
|
208 | var s = this.state,
|
209 | a = this.v;
|
210 | soon(function () {
|
211 | s(client, a);
|
212 | });
|
213 | }
|
214 |
|
215 | return p;
|
216 | }
|
217 | };
|
218 |
|
219 | function STATE_FULFILLED(c, arg) {
|
220 | if (typeof c.y === "function") {
|
221 | try {
|
222 | var yret = c.y.call(undefined, arg);
|
223 | c.p.resolve(yret);
|
224 | } catch (err) {
|
225 | c.p.reject(err);
|
226 | }
|
227 | } else c.p.resolve(arg);
|
228 | }
|
229 |
|
230 | function STATE_REJECTED(c, reason) {
|
231 | if (typeof c.n === "function") {
|
232 | try {
|
233 | var yret = c.n.call(undefined, reason);
|
234 | c.p.resolve(yret);
|
235 | } catch (err) {
|
236 | c.p.reject(err);
|
237 | }
|
238 | } else c.p.reject(reason);
|
239 | }
|
240 |
|
241 | Zousan.resolve = function (val) {
|
242 | if (val && val instanceof Zousan) return val;
|
243 | var z = new Zousan();
|
244 | z.resolve(val);
|
245 | return z;
|
246 | };
|
247 |
|
248 | Zousan.reject = function (err) {
|
249 | if (err && err instanceof Zousan) return err;
|
250 | var z = new Zousan();
|
251 | z.reject(err);
|
252 | return z;
|
253 | };
|
254 |
|
255 | Zousan.version = "2.3.3-nodent";
|
256 | return Zousan;
|
257 | })();
|
258 | }
|
259 |
|
260 | var resolver = this;
|
261 |
|
262 | switch (catcher) {
|
263 | case true:
|
264 | return new $asyncbind.Thenable(boundThen);
|
265 |
|
266 | case 0:
|
267 | return new $asyncbind.LazyThenable(boundThen);
|
268 |
|
269 | case undefined:
|
270 | boundThen.then = boundThen;
|
271 | return boundThen;
|
272 |
|
273 | default:
|
274 | return function () {
|
275 | try {
|
276 | return resolver.apply(self, arguments);
|
277 | } catch (ex) {
|
278 | return catcher(ex);
|
279 | }
|
280 | };
|
281 | }
|
282 |
|
283 | function boundThen() {
|
284 | return resolver.apply(self, arguments);
|
285 | }
|
286 | };
|
287 |
|
288 | function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
289 |
|
290 | function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }
|
291 |
|
292 | const Path = require("path");
|
293 |
|
294 | const ARSON = require("arson");
|
295 |
|
296 | const _require = require("@patternplate/validate-config"),
|
297 | validate = _require.validate;
|
298 |
|
299 | const WebSocket = require("ws");
|
300 |
|
301 | const _require2 = require("@patternplate/load-config"),
|
302 | loadConfig = _require2.loadConfig;
|
303 |
|
304 | const _require3 = require("./create-compiler"),
|
305 | createCompiler = _require3.createCompiler;
|
306 |
|
307 | const debug = require("util").debuglog("PATTERNPLATE");
|
308 |
|
309 | module.exports.createSubscription = function createSubscription(context) {
|
310 | const queues = context.queues,
|
311 | config = context.config,
|
312 | cwd = context.cwd,
|
313 | wss = context.wss,
|
314 | watcher = context.watcher;
|
315 | return handler => {
|
316 | debug("subscribing to webpack and fs events");
|
317 |
|
318 |
|
319 | wss.on("connection", ws => {
|
320 | ws.on("error", err => {
|
321 | if (err.errno === "ECONNRESET") {
|
322 | return;
|
323 | }
|
324 |
|
325 | console.error(err);
|
326 | });
|
327 | });
|
328 | const send = getSender(wss, handler);
|
329 | queues.client.subscribe(queue => {
|
330 | const _queue = _slicedToArray(queue, 1),
|
331 | message = _queue[0];
|
332 |
|
333 | send({
|
334 | type: message.type,
|
335 | payload: message.payload
|
336 | });
|
337 | });
|
338 | queues.client.subscribe(queue => {
|
339 | const _queue2 = _slicedToArray(queue, 1),
|
340 | message = _queue2[0];
|
341 |
|
342 | send({
|
343 | type: message.type,
|
344 | payload: message.payload
|
345 | });
|
346 | });
|
347 | let configError = false;
|
348 | watcher.subscribe(message => {
|
349 | if (message.type === "change" && message.payload.contentType === "config") {
|
350 | (() => new Promise(function ($return, $error) {
|
351 | var _ref, loadedConfig, filepath, _validate, _validate2, error, _ref2, _ref3, clientQueue, serverQueue;
|
352 |
|
353 | return loadConfig({
|
354 | cwd
|
355 | }).then(function ($await_3) {
|
356 | _ref = $await_3, loadedConfig = _ref.config, filepath = _ref.filepath;
|
357 | _validate = validate({
|
358 | target: config,
|
359 | name: filepath
|
360 | }), _validate2 = _slicedToArray(_validate, 1), error = _validate2[0];
|
361 |
|
362 | if (error) {
|
363 | configError = true;
|
364 | send({
|
365 | type: "error",
|
366 | payload: error
|
367 | });
|
368 | return $return();
|
369 | }
|
370 |
|
371 | if (configError) {
|
372 | console.log(`Resolved config error, applying ${filepath}`);
|
373 | configError = false;
|
374 | }
|
375 |
|
376 | Object.assign(config, loadedConfig);
|
377 | queues.client.stop();
|
378 | queues.server.stop();
|
379 | return Promise.all([createCompiler({
|
380 | config,
|
381 | cwd,
|
382 | target: "web"
|
383 | }), createCompiler({
|
384 | config,
|
385 | cwd,
|
386 | target: "node"
|
387 | })]).then(function ($await_4) {
|
388 | _ref2 = $await_4, _ref3 = _slicedToArray(_ref2, 2), clientQueue = _ref3[0], serverQueue = _ref3[1];
|
389 | queues.client = clientQueue;
|
390 | queues.server = serverQueue;
|
391 | return $return();
|
392 | }.$asyncbind(this, $error), $error);
|
393 | }.$asyncbind(this, $error), $error);
|
394 | }.$asyncbind(this)))().catch(err => {
|
395 | configError = true;
|
396 | send({
|
397 | type: "error",
|
398 | payload: err
|
399 | });
|
400 | });
|
401 | }
|
402 |
|
403 | send(message);
|
404 | });
|
405 | };
|
406 | };
|
407 |
|
408 | function getSender(wss, handler) {
|
409 | return message => {
|
410 | if (typeof handler === "function") {
|
411 | handler(message);
|
412 | }
|
413 |
|
414 | wss.clients.forEach(client => {
|
415 | if (client.readyState === WebSocket.OPEN) {
|
416 | client.send(ARSON.stringify(message));
|
417 | }
|
418 | });
|
419 | };
|
420 | }
|
421 |
|
\ | No newline at end of file |