MediaWiki:Gadget-libAsyncLock.js
Note: After saving, you may have to bypass your browser's cache to see the changes.
- Firefox / Safari: Hold Shift while clicking Reload, or press either Ctrl-F5 or Ctrl-R (⌘-R on a Mac)
- Google Chrome: Press Ctrl-Shift-R (⌘-Shift-R on a Mac)
- Internet Explorer: Hold Ctrl while clicking Refresh, or press Ctrl-F5
- Opera: Go to Menu → Settings (Opera → Preferences on a Mac) and then to Privacy & security → Clear browsing data → Cached images and files.
/* <pre> */
/**
* -------------------------------------------------------------------------
* !!! DON'T MODIFY THIS PAGE MANUALLY, YOUR CHANGES WILL BE OVERWRITTEN !!!
* -------------------------------------------------------------------------
*/
var _addText = '{{GHIACode|page=GHIA:MoegirlPediaInterfaceCodes/blob/master/src/gadgets/libAsyncLock/MediaWiki:Gadget-libAsyncLock.js|user=[[U:AnnAngela]]|longId=3820b56ff2ac6eb2e6bb95dd82dd71db679b0c81|shortId=3820b56|message=auto: auto browserify - commit from GitHub Actions}}';
"use strict";
(function () {
var _$browser_3 = {};
var process = _$browser_3 = {};
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout() {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
}
else {
cachedSetTimeout = defaultSetTimout;
}
}
catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
}
else {
cachedClearTimeout = defaultClearTimeout;
}
}
catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
}());
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
return setTimeout(fun, 0);
}
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
return cachedSetTimeout(fun, 0);
}
catch (e) {
try {
return cachedSetTimeout.call(null, fun, 0);
}
catch (e) {
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
return clearTimeout(marker);
}
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
return cachedClearTimeout(marker);
}
catch (e) {
try {
return cachedClearTimeout.call(null, marker);
}
catch (e) {
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
}
else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while (len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = '';
process.versions = {};
function noop() { }
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return []; };
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/'; };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function () { return 0; };
var _$AsyncLock_2 = {};
(function (process) {
(function () {
'use strict';
var AsyncLock = function (opts) {
opts = opts || {};
this.Promise = opts.Promise || Promise;
this.queues = Object.create(null);
this.domainReentrant = opts.domainReentrant || false;
if (this.domainReentrant) {
if (typeof process === 'undefined' || typeof process.domain === 'undefined') {
throw new Error('Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, ' +
'use a NodeJS version that still implements Domain, or install a browser polyfill.');
}
this.domains = Object.create(null);
}
this.timeout = opts.timeout || AsyncLock.DEFAULT_TIMEOUT;
this.maxOccupationTime = opts.maxOccupationTime || AsyncLock.DEFAULT_MAX_OCCUPATION_TIME;
if (opts.maxPending === Infinity || (Number.isInteger(opts.maxPending) && opts.maxPending >= 0)) {
this.maxPending = opts.maxPending;
}
else {
this.maxPending = AsyncLock.DEFAULT_MAX_PENDING;
}
};
AsyncLock.DEFAULT_TIMEOUT = 0;
AsyncLock.DEFAULT_MAX_OCCUPATION_TIME = 0;
AsyncLock.DEFAULT_MAX_PENDING = 1000;
AsyncLock.prototype.acquire = function (key, fn, cb, opts) {
if (Array.isArray(key)) {
return this._acquireBatch(key, fn, cb, opts);
}
if (typeof (fn) !== 'function') {
throw new Error('You must pass a function to execute');
}
var deferredResolve = null;
var deferredReject = null;
var deferred = null;
if (typeof (cb) !== 'function') {
opts = cb;
cb = null;
deferred = new this.Promise(function (resolve, reject) {
deferredResolve = resolve;
deferredReject = reject;
});
}
opts = opts || {};
var resolved = false;
var timer = null;
var occupationTimer = null;
var self = this;
var done = function (locked, err, ret) {
if (occupationTimer) {
clearTimeout(occupationTimer);
occupationTimer = null;
}
if (locked) {
if (!!self.queues[key] && self.queues[key].length === 0) {
delete self.queues[key];
}
if (self.domainReentrant) {
delete self.domains[key];
}
}
if (!resolved) {
if (!deferred) {
if (typeof (cb) === 'function') {
cb(err, ret);
}
}
else {
if (err) {
deferredReject(err);
}
else {
deferredResolve(ret);
}
}
resolved = true;
}
if (locked) {
if (!!self.queues[key] && self.queues[key].length > 0) {
self.queues[key].shift()();
}
}
};
var exec = function (locked) {
if (resolved) {
return done(locked);
}
if (timer) {
clearTimeout(timer);
timer = null;
}
if (self.domainReentrant && locked) {
self.domains[key] = process.domain;
}
if (fn.length === 1) {
var called = false;
try {
fn(function (err, ret) {
if (!called) {
called = true;
done(locked, err, ret);
}
});
}
catch (err) {
if (!called) {
called = true;
done(locked, err);
}
}
}
else {
self._promiseTry(function () {
return fn();
})
.then(function (ret) {
done(locked, undefined, ret);
}, function (error) {
done(locked, error);
});
}
};
if (self.domainReentrant && !!process.domain) {
exec = process.domain.bind(exec);
}
if (!self.queues[key]) {
self.queues[key] = [];
exec(true);
}
else if (self.domainReentrant && !!process.domain && process.domain === self.domains[key]) {
exec(false);
}
else if (self.queues[key].length >= self.maxPending) {
done(false, new Error('Too many pending tasks in queue ' + key));
}
else {
var taskFn = function () {
exec(true);
};
if (opts.skipQueue) {
self.queues[key].unshift(taskFn);
}
else {
self.queues[key].push(taskFn);
}
var timeout = opts.timeout || self.timeout;
if (timeout) {
timer = setTimeout(function () {
timer = null;
done(false, new Error('async-lock timed out in queue ' + key));
}, timeout);
}
}
var maxOccupationTime = opts.maxOccupationTime || self.maxOccupationTime;
if (maxOccupationTime) {
occupationTimer = setTimeout(function () {
if (!!self.queues[key]) {
done(false, new Error('Maximum occupation time is exceeded in queue ' + key));
}
}, maxOccupationTime);
}
if (deferred) {
return deferred;
}
};
AsyncLock.prototype._acquireBatch = function (keys, fn, cb, opts) {
if (typeof (cb) !== 'function') {
opts = cb;
cb = null;
}
var self = this;
var getFn = function (key, fn) {
return function (cb) {
self.acquire(key, fn, cb, opts);
};
};
var fnx = keys.reduceRight(function (prev, key) {
return getFn(key, prev);
}, fn);
if (typeof (cb) === 'function') {
fnx(cb);
}
else {
return new this.Promise(function (resolve, reject) {
if (fnx.length === 1) {
fnx(function (err, ret) {
if (err) {
reject(err);
}
else {
resolve(ret);
}
});
}
else {
resolve(fnx());
}
});
}
};
AsyncLock.prototype.isBusy = function (key) {
if (!key) {
return Object.keys(this.queues).length > 0;
}
else {
return !!this.queues[key];
}
};
AsyncLock.prototype._promiseTry = function (fn) {
try {
return this.Promise.resolve(fn());
}
catch (e) {
return this.Promise.reject(e);
}
};
_$AsyncLock_2 = AsyncLock;
}).call(this);
}).call(this, _$browser_3);
'use strict';
var _$asyncLock_1 = _$AsyncLock_2;
var _$input_4 = {};
(function (global) {
(function () {
"use strict";
var _asyncLock = _interopRequireDefault(_$asyncLock_1);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
global["AsyncLock"] = _asyncLock["default"];
}).call(this);
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
}());
/* </pre> */
