astx
Version:
super powerful structural search and replace for JavaScript and TypeScript to automate your refactoring
519 lines (452 loc) • 15.3 kB
JavaScript
var _interopRequireDefault = require('@babel/runtime/helpers/interopRequireDefault')
Object.defineProperty(exports, '__esModule', {
value: true,
})
exports['default'] = void 0
var _regenerator = _interopRequireDefault(require('@babel/runtime/regenerator'))
var _toConsumableArray2 = _interopRequireDefault(
require('@babel/runtime/helpers/toConsumableArray')
)
var _asyncToGenerator2 = _interopRequireDefault(
require('@babel/runtime/helpers/asyncToGenerator')
)
var _classCallCheck2 = _interopRequireDefault(
require('@babel/runtime/helpers/classCallCheck')
)
var _createClass2 = _interopRequireDefault(
require('@babel/runtime/helpers/createClass')
)
var _defineProperty2 = _interopRequireDefault(
require('@babel/runtime/helpers/defineProperty')
)
var _worker_threads = require('worker_threads')
var _pEvent = _interopRequireDefault(require('p-event'))
function _createForOfIteratorHelper(o, allowArrayLike) {
var it =
(typeof Symbol !== 'undefined' && o[Symbol.iterator]) || o['@@iterator']
if (!it) {
if (
Array.isArray(o) ||
(it = _unsupportedIterableToArray(o)) ||
(allowArrayLike && o && typeof o.length === 'number')
) {
if (it) o = it
var i = 0
var F = function F() {}
return {
s: F,
n: function n() {
if (i >= o.length)
return {
done: true,
}
return {
done: false,
value: o[i++],
}
},
e: function e(_e) {
throw _e
},
f: F,
}
}
throw new TypeError(
'Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
)
}
var normalCompletion = true,
didErr = false,
err
return {
s: function s() {
it = it.call(o)
},
n: function n() {
var step = it.next()
normalCompletion = step.done
return step
},
e: function e(_e2) {
didErr = true
err = _e2
},
f: function f() {
try {
if (!normalCompletion && it['return'] != null) it['return']()
} finally {
if (didErr) throw err
}
},
}
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return
if (typeof o === 'string') return _arrayLikeToArray(o, minLen)
var n = Object.prototype.toString.call(o).slice(8, -1)
if (n === 'Object' && o.constructor) n = o.constructor.name
if (n === 'Map' || n === 'Set') return Array.from(o)
if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
return _arrayLikeToArray(o, minLen)
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i]
}
return arr2
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object)
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object)
enumerableOnly &&
(symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable
})),
keys.push.apply(keys, symbols)
}
return keys
}
function _objectSpread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {}
i % 2
? ownKeys(Object(source), !0).forEach(function (key) {
;(0, _defineProperty2['default'])(target, key, source[key])
})
: Object.getOwnPropertyDescriptors
? Object.defineProperties(
target,
Object.getOwnPropertyDescriptors(source)
)
: ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(
target,
key,
Object.getOwnPropertyDescriptor(source, key)
)
})
}
return target
}
var AstxWorker = /*#__PURE__*/ (function () {
function AstxWorker() {
;(0, _classCallCheck2['default'])(this, AstxWorker)
;(0, _defineProperty2['default'])(this, 'worker', void 0)
;(0, _defineProperty2['default'])(this, '_seq', 0)
;(0, _defineProperty2['default'])(this, '_running', false)
;(0, _defineProperty2['default'])(this, 'ended', false)
this.startWorker()
}
;(0, _createClass2['default'])(AstxWorker, [
{
key: 'end',
value: (function () {
var _end = (0, _asyncToGenerator2['default'])(
/*#__PURE__*/ _regenerator['default'].mark(function _callee() {
var worker
return _regenerator['default'].wrap(
function _callee$(_context) {
while (1) {
switch ((_context.prev = _context.next)) {
case 0:
if (!this.ended) {
_context.next = 2
break
}
return _context.abrupt('return')
case 2:
this.ended = true
worker = this.worker
if (!worker) {
_context.next = 8
break
}
_context.next = 7
return worker.terminate()
case 7:
this.worker = undefined
case 8:
case 'end':
return _context.stop()
}
}
},
_callee,
this
)
})
)
function end() {
return _end.apply(this, arguments)
}
return end
})(),
},
{
key: 'startWorker',
value: function startWorker() {
var _this = this
if (this.ended) return
var worker = new _worker_threads.Worker(
require.resolve('./AstxWorkerEntry.js')
)
this.worker = worker
worker.once(
'exit',
/*#__PURE__*/ (0, _asyncToGenerator2['default'])(
/*#__PURE__*/ _regenerator['default'].mark(function _callee2() {
return _regenerator['default'].wrap(function _callee2$(
_context2
) {
while (1) {
switch ((_context2.prev = _context2.next)) {
case 0:
_this.worker = undefined
if (!_this.ended) {
_context2.next = 3
break
}
return _context2.abrupt('return')
case 3:
_context2.next = 5
return new Promise(function (r) {
return setTimeout(r, 1000)
})
case 5:
_this.startWorker()
case 6:
case 'end':
return _context2.stop()
}
}
},
_callee2)
})
)
)
},
},
{
key: 'running',
get: function get() {
return this.running
},
},
{
key: 'getWorker',
value: (function () {
var _getWorker = (0, _asyncToGenerator2['default'])(
/*#__PURE__*/ _regenerator['default'].mark(function _callee3() {
return _regenerator['default'].wrap(
function _callee3$(_context3) {
while (1) {
switch ((_context3.prev = _context3.next)) {
case 0:
if (this.worker) {
_context3.next = 5
break
}
_context3.next = 3
return new Promise(function (r) {
return setTimeout(r, 1000)
})
case 3:
_context3.next = 0
break
case 5:
if (!this.worker) {
_context3.next = 7
break
}
return _context3.abrupt('return', this.worker)
case 7:
throw new Error('unexpected')
case 8:
case 'end':
return _context3.stop()
}
}
},
_callee3,
this
)
})
)
function getWorker() {
return _getWorker.apply(this, arguments)
}
return getWorker
})(),
},
{
key: 'runTransformOnFile',
value: (function () {
var _runTransformOnFile = (0, _asyncToGenerator2['default'])(
/*#__PURE__*/ _regenerator['default'].mark(function _callee4(_ref2) {
var file,
transform,
transformFile,
config,
signal,
worker,
seq,
_on,
_ref3,
promise,
message,
error,
_result$reports,
result,
_iterator,
_step,
report
return _regenerator['default'].wrap(
function _callee4$(_context4) {
while (1) {
switch ((_context4.prev = _context4.next)) {
case 0:
;(file = _ref2.file),
(transform = _ref2.transform),
(transformFile = _ref2.transformFile),
(config = _ref2.config),
(signal = _ref2.signal)
_context4.next = 3
return this.getWorker()
case 3:
worker = _context4.sent
if (!this._running) {
_context4.next = 6
break
}
throw new Error('a transform is currently running')
case 6:
seq = this._seq++
_context4.prev = 7
this._running = true
signal === null || signal === void 0
? void 0
: (_on = (_ref3 = signal).on) === null || _on === void 0
? void 0
: _on.call(_ref3, 'abort', function () {
worker.postMessage({
type: 'abort',
seq: seq,
})
})
promise = Promise.race(
[
(0, _pEvent['default'])(worker, 'message', {
filter: function filter(event) {
return event.seq === seq
},
rejectionEvents: ['error', 'exit'],
})['catch'](function (reason) {
return typeof reason === 'number'
? 'worker exited with code '.concat(reason)
: reason
}),
].concat(
(0, _toConsumableArray2['default'])(
signal
? [
(0, _pEvent['default'])(signal, '', {
rejectionEvents: ['abort'],
}),
]
: []
)
)
)
promise['catch'](function () {
// ignore
})
worker.postMessage(
_objectSpread(
{
type: 'runTransformOnFile',
seq: seq,
file: file,
transform: transformFile ? undefined : transform,
transformFile: transformFile,
},
config && {
config: config,
}
)
)
_context4.next = 15
return promise
case 15:
message = _context4.sent
_context4.t0 = message.type
_context4.next =
_context4.t0 === 'error'
? 19
: _context4.t0 === 'transformResult'
? 22
: 25
break
case 19:
error = new Error(message.error.message)
error.stack = message.error.stack
throw error
case 22:
result = message.result
if (
(_result$reports = result.reports) !== null &&
_result$reports !== void 0 &&
_result$reports.length &&
transform !== null &&
transform !== void 0 &&
transform.onReport
) {
_iterator = _createForOfIteratorHelper(result.reports)
try {
for (_iterator.s(); !(_step = _iterator.n()).done; ) {
report = _step.value
transform.onReport({
file: file,
report: report,
})
}
} catch (err) {
_iterator.e(err)
} finally {
_iterator.f()
}
}
return _context4.abrupt('return', result)
case 25:
throw new Error(
'unknown message: '.concat(JSON.stringify(message))
)
case 26:
_context4.prev = 26
this._running = false
return _context4.finish(26)
case 29:
case 'end':
return _context4.stop()
}
}
},
_callee4,
this,
[[7, , 26, 29]]
)
})
)
function runTransformOnFile(_x) {
return _runTransformOnFile.apply(this, arguments)
}
return runTransformOnFile
})(),
},
])
return AstxWorker
})()
exports['default'] = AstxWorker