_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q58800
|
$version
|
validation
|
function $version(byte) {
version = (version << 8) | byte;
if (++offset < 4) return $version;
if (version >= 2 && version <= 3) {
offset = 0;
return $num;
}
throw new Error("Invalid version number " + num);
}
|
javascript
|
{
"resource": ""
}
|
q58801
|
$num
|
validation
|
function $num(byte) {
num = (num << 8) | byte;
if (++offset < 4) return $num;
offset = 0;
emit({version: version, num: num});
return $header;
}
|
javascript
|
{
"resource": ""
}
|
q58802
|
emitObject
|
validation
|
function emitObject() {
var body = bodec.join(parts);
if (body.length !== length) {
throw new Error("Body length mismatch");
}
var item = {
type: numToType[type],
size: length,
body: body,
offset: start
};
if (ref) item.ref = ref;
parts.length = 0;
start = 0;
offset = 0;
type = 0;
length = 0;
ref = null;
emit(item);
}
|
javascript
|
{
"resource": ""
}
|
q58803
|
$body
|
validation
|
function $body(byte, i, chunk) {
if (inf.write(byte)) return $body;
var buf = inf.flush();
if (buf.length !== length) throw new Error("Length mismatch, expected " + length + " got " + buf.length);
inf.recycle();
if (buf.length) {
parts.push(buf);
}
emitObject();
// If this was all the objects, start calculating the sha1sum
if (--num) return $header;
sha1sum.update(bodec.slice(chunk, 0, i + 1));
return $checksum;
}
|
javascript
|
{
"resource": ""
}
|
q58804
|
$checksum
|
validation
|
function $checksum(byte) {
checksum += toHex(byte);
if (++offset < 20) return $checksum;
var actual = sha1sum.digest();
if (checksum !== actual) throw new Error("Checksum mismatch: " + actual + " != " + checksum);
}
|
javascript
|
{
"resource": ""
}
|
q58805
|
validation
|
function(elem) {
var pattern = new RegExp(_filterValue, 'i');
var element = elem;
if (pattern.test(element.textContent)) {
element.style.display = '';
} else {
element.style.display = 'none';
}
}
|
javascript
|
{
"resource": ""
}
|
|
q58806
|
validation
|
function() {
var collection = _logContainer.childNodes;
var i = collection.length;
if (i === 0) {
return;
}
while (i) {
_filterElement(collection[i - 1]);
i -= 1;
}
window.scrollTo(0, document.body.scrollHeight);
}
|
javascript
|
{
"resource": ""
}
|
|
q58807
|
validation
|
function(filterInput, uri) {
var _url = new URL(uri);
var _filterValueFromURL = _url.searchParams.get('filter');
if (typeof _filterValueFromURL !== 'undefined' && _filterValueFromURL !== null) {
_filterValue = _filterValueFromURL;
filterInput.value = _filterValue; // eslint-disable-line
}
}
|
javascript
|
{
"resource": ""
}
|
|
q58808
|
validation
|
function(value, uri) {
var _url = new URL(uri);
var _params = new URLSearchParams(_url.search.slice(1));
if (value === '') {
_params.delete('filter');
} else {
_params.set('filter', value);
}
_url.search = _params.toString();
window.history.replaceState(null, document.title, _url.toString());
}
|
javascript
|
{
"resource": ""
}
|
|
q58809
|
init
|
validation
|
function init(opts) {
var self = this;
// Elements
_logContainer = opts.container;
_filterInput = opts.filterInput;
_filterInput.focus();
_topbar = opts.topbar;
_body = opts.body;
_setFilterValueFromURL(_filterInput, window.location.toString());
// Filter input bind
_filterInput.addEventListener('keyup', function(e) {
// ESC
if (e.keyCode === 27) {
this.value = '';
_filterValue = '';
} else {
_filterValue = this.value;
}
_setFilterParam(_filterValue, window.location.toString());
_filterLogs();
});
// Favicon counter bind
window.addEventListener(
'blur',
function() {
_isWindowFocused = false;
},
true
);
window.addEventListener(
'focus',
function() {
_isWindowFocused = true;
_faviconReset();
},
true
);
// socket.io init
_socket = opts.socket;
_socket
.on('options:lines', function(limit) {
_linesLimit = limit;
})
.on('options:hide-topbar', function() {
_topbar.className += ' hide';
_body.className = 'no-topbar';
})
.on('options:no-indent', function() {
_logContainer.className += ' no-indent';
})
.on('options:highlightConfig', function(highlightConfig) {
_highlightConfig = highlightConfig;
})
.on('line', function(line) {
self.log(line);
});
}
|
javascript
|
{
"resource": ""
}
|
q58810
|
validation
|
function (bBox) {
var size = Math.max(bBox[3], bBox[4], bBox[5]);
var ratio = Math.max(viewer._width, viewer._height) / Math.min(viewer._width, viewer._height);
viewer._distance = size / Math.tan(viewer.perspectiveCamera.fov * Math.PI / 180.0) * ratio * 1.0;
}
|
javascript
|
{
"resource": ""
}
|
|
q58811
|
handleMouseDown
|
validation
|
function handleMouseDown(event) {
mouseDown = true;
lastMouseX = event.clientX;
lastMouseY = event.clientY;
startX = event.clientX;
startY = event.clientY;
//get coordinates within canvas (with the right orientation)
var r = viewer._canvas.getBoundingClientRect();
var viewX = startX - r.left;
var viewY = viewer._height - (startY - r.top);
//this is for picking
id = viewer._getID(viewX, viewY);
/**
* Occurs when mousedown event happens on underlying canvas.
*
* @event xViewer#mouseDown
* @type {object}
* @param {Number} id - product ID of the element or null if there wasn't any product under mouse
*/
viewer._fire('mouseDown', {id: id});
//keep information about the mouse button
switch (event.button) {
case 0:
button = 'left';
break;
case 1:
button = 'middle';
break;
case 2:
button = 'right';
break;
default:
button = 'left';
break;
}
viewer._disableTextSelection();
}
|
javascript
|
{
"resource": ""
}
|
q58812
|
clone
|
validation
|
function clone(obj) {
var key, copy = {};
if (!obj) {
return;
}
for (key in obj) {
copy[key] = obj[key];
}
return copy;
}
|
javascript
|
{
"resource": ""
}
|
q58813
|
navigate
|
validation
|
function navigate(n) {
var position = currentPosition();
var numSlides = document.getElementsByClassName('slide').length;
/* Positions are 1-indexed, so we need to add and subtract 1 */
var nextPosition = (position - 1 + n) % numSlides + 1;
/* Normalize nextPosition in-case of a negative modulo result */
nextPosition = (nextPosition - 1 + numSlides) % numSlides + 1;
document.getElementById('slide-' + position).classList.add('hidden');
document.getElementById('slide-' + nextPosition).classList.remove('hidden');
updateProgress();
updateURL();
updateTabIndex();
}
|
javascript
|
{
"resource": ""
}
|
q58814
|
updateURL
|
validation
|
function updateURL() {
try {
window.history.replaceState({} , null, '#' + currentPosition());
} catch (e) {
window.location.hash = currentPosition();
}
}
|
javascript
|
{
"resource": ""
}
|
q58815
|
updateProgress
|
validation
|
function updateProgress() {
var progressBar = document.querySelector('.progress-bar');
if (progressBar !== null) {
var numSlides = document.getElementsByClassName('slide').length;
var position = currentPosition() - 1;
var percent = (numSlides === 1) ? 100 : 100 * position / (numSlides - 1);
progressBar.style.width = percent.toString() + '%';
}
}
|
javascript
|
{
"resource": ""
}
|
q58816
|
updateTabIndex
|
validation
|
function updateTabIndex() {
var allLinks = document.querySelectorAll('.slide a');
var position = currentPosition();
var currentPageLinks = document.getElementById('slide-' + position).querySelectorAll('a');
var i;
for (i = 0; i < allLinks.length; i++) {
allLinks[i].setAttribute('tabindex', -1);
}
for (i = 0; i < currentPageLinks.length; i++) {
currentPageLinks[i].removeAttribute('tabindex');
}
}
|
javascript
|
{
"resource": ""
}
|
q58817
|
pluck
|
validation
|
function pluck(obj, fields) {
var plucked = {};
if (!obj) {
return;
}
fields.forEach(function (field) {
plucked[field] = obj[field];
});
return plucked;
}
|
javascript
|
{
"resource": ""
}
|
q58818
|
loadSingle
|
validation
|
function loadSingle(source) {
var promise;
if (source.match(/^https?:\/\//)) {
promise = httpGetPromise(source);
} else {
promise = readFilePromise(normalizePath(source));
}
return promise;
}
|
javascript
|
{
"resource": ""
}
|
q58819
|
populateSingle
|
validation
|
function populateSingle(filename, destination, key) {
return loadSingle(filename)
.then(function (data) {
if (data) {
/**
* If the key points to an array in the destination map, then
* we should also append to an array in the `loaded` section
* of the map.
*
* This is useful for style resources, where `external.style` may
* refer to a list of resources to be loaded.
*/
if (Object.prototype.toString.call(destination[key]) === '[object Array]') {
destination.loaded[key] = destination.loaded[key] || [];
destination.loaded[key].push(data);
} else {
destination.loaded[key] = data;
}
}
});
}
|
javascript
|
{
"resource": ""
}
|
q58820
|
load
|
validation
|
function load(map, options) {
var promises = [];
var loaded = {};
var filename;
options = options || {};
for (var key in map) {
if (map.hasOwnProperty(key)) {
if (!map[key] || map[key].length === 0) {
continue;
}
filename = map[key];
if (!options.external) {
filename = path.resolve(ROOT_DIR, filename);
}
promises.push(loadSingle(filename)
.then((function (_key) {
return function (data) {
loaded[_key] = data;
};
})(key)));
}
}
map.loaded = loaded;
return Q.all(promises);
}
|
javascript
|
{
"resource": ""
}
|
q58821
|
loadSettings
|
validation
|
function loadSettings(source, ctx) {
return loadSingle(source).then(function (data) {
if (data) {
data = JSON.parse(data);
ctx.override = data.override;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q58822
|
readFilePromise
|
validation
|
function readFilePromise(filename) {
var deferred;
deferred = Q.defer();
fs.readFile(filename, 'utf-8', function (err, contents) {
if (err) {
if (err.code === 'ENOENT') {
debug(err.code + ': ' + filename);
return deferred.resolve();
}
debug(err + ' ' + filename);
// TODO: better error handling
deferred.reject(err);
} else {
debug('read ' + filename);
deferred.resolve(contents);
}
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q58823
|
httpGetPromise
|
validation
|
function httpGetPromise(url) {
var deferred = Q.defer(), get;
var cb = function (res) {
var data = '';
res.on('data', function (chunk) {
data += chunk;
});
res.on('err', function (err) {
debug(err + ' ' + url);
deferred.reject(err);
});
res.on('end', function () {
if (res.statusCode !== 200) {
debug(res.statusCode + ': ' + url);
deferred.resolve();
} else {
debug('fetched ' + url);
deferred.resolve(data);
}
});
};
if (url.match(/^https/)) {
get = https.get(url, cb);
} else {
get = http.get(url, cb);
}
get.on('error', function (err) {
deferred.resolve();
debug(err + ': ' + url);
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q58824
|
getUserHome
|
validation
|
function getUserHome() {
return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
}
|
javascript
|
{
"resource": ""
}
|
q58825
|
Request
|
validation
|
function Request(method, urlPath, cache) {
this._method = method;
this._urlPath = urlPath;
this._cache = cache;
this._queryParams = [];
// _postParams should initially be null instead of {} because we want to allow people to send POST requests with
// empty data sets (if they need to). This way, we can differentiate between a default of null, an empty data set,
// and a populated data set.
this._postParams = null;
this._headers = {};
this._timeout = null;
this._type = "json"; // superagent's default, only for POST/PUT/PATCH methods
// public field
this.aborted = undefined; //default to undefined
}
|
javascript
|
{
"resource": ""
}
|
q58826
|
logRequestError
|
validation
|
function logRequestError(err) {
var {response} = err;
if (!response) {
logger.warning(`ReactServerAgent raised exception for URL ${this._urlPath}`, err);
} else if (response.notFound) {
// 404? don't care about response
logger.warning(`Resource not found on server: ${this._urlPath}`);
} else if (response.serverError) {
logger.warning(`Received server error for URL ${this._urlPath}`, err);
} else {
logger.warning(`Unexpected status code returned for URL ${this._urlPath}`, err);
}
}
|
javascript
|
{
"resource": ""
}
|
q58827
|
validation
|
function(fn, opts, trim, basePath, prefix){
var slashPattern = isWindows
?/\\/g
:/\//g
var name = fn.substring(basePath.length+trim.length, fn.length)
.replace(/\.jsx?$/, '')
.replace(slashPattern,'.')
if (opts.label) {
name += '.'+opts.label
}
if (prefix) {
name = prefix + name
}
return name;
}
|
javascript
|
{
"resource": ""
}
|
|
q58828
|
writeBody
|
validation
|
function writeBody(req, res, context, start, page) {
// standardize to an array of EarlyPromises of ReactElements
var elementPromises = PageUtil.standardizeElements(page.getElements());
// This is where we'll store our rendered HTML strings. A value of
// `undefined` means we haven't rendered that element yet.
var rendered = elementPromises.map(() => ELEMENT_PENDING);
// We need to return a promise that resolves when we're done, so we'll
// maintain an array of deferreds that we punch out as we render
// elements and we'll return a promise that resolves when they've all
// been hit.
var dfds = elementPromises.map(() => Q.defer());
var doElement = (element, index) => {
// Exceeded `FAILSAFE_RENDER_TIMEOUT`. Bummer.
if (rendered[index] === ELEMENT_ALREADY_WRITTEN) return;
rendered[index] = renderElement(res, element, context);
// If we've just rendered the next element to be written we'll
// write it out.
writeElements(res, rendered);
dfds[index].resolve();
};
// Render elements as their data becomes available.
elementPromises.forEach((promise, index) => promise
.then(element => doElement(element, index))
.catch(e => {
logger.error(`Error rendering element ${index}`, e)
// TODO: the error handling here should probably be merged
// somehow with renderElement so that we get timing info.
// In the case where there was an exception thrown while rendering,
// the next three lines are effectively a no-op. In the case where
// the element promise was rejected, this prevents a hang until
// FAILSAFE_RENDER_TIMEOUT has passed.
// No way we can recover in the second case, so let's just move on.
// We'll call `writeElements` just in case everything is ready
// after us.
// This doesn't completely handle the extremely unlikely case that:
// 1) `renderElement` successfully rendered this element, and
// 2) `writeElements` successfully wrote it, but...
// 3) `writeElements` threw after this element was written.
//
// We'll make a good-faith effort, but in this rare case writeElements is probably
// going to fail again when we call it here. At least if that happens, _this_
// particular element should show up properly on the page, even though the page
// overall could be totally horked. And we won't have a 20s timeout...
try {
if (rendered[index] !== ELEMENT_ALREADY_WRITTEN) {
rendered[index] = '';
writeElements(res, rendered);
}
} finally {
// try _really_ hard to resolve this deferred, to avoid a 20s hang.
dfds[index].resolve();
}
})
// just in case writeElements throws in our error callback above.
.catch(e => logger.error(`Error recovering from error rendering element ${index}`, e))
);
// Some time has already elapsed since the request started.
// Note that you can override `FAILSAFE_RENDER_TIMEOUT` with a
// `?_debug_render_timeout={ms}` query string parameter.
var totalWait = DebugUtil.getRenderTimeout() || FAILSAFE_RENDER_TIMEOUT
, timeRemaining = totalWait - (new Date - start)
var retval = Q.defer();
var writeBodyDfd = Q.defer();
// If we exceed the timeout then we'll just send empty elements for
// anything that hadn't rendered yet.
writeBodyDfd.promise.catch((err) => {
// Write out what we've got.
writeElements(res, rendered.map(
value => value === ELEMENT_PENDING?'':value
));
// If it hasn't arrived by now, we're not going to wait for it.
RLS().lateArrivals = undefined;
// Let the client know it's not getting any more data.
renderScriptsAsync([{ text: `__reactServerClientController.failArrival()` }], res)
//Log timeout error but still resolve so we continue in the lifecycle process
logger.error("Error in writeBody", err);
retval.resolve();
});
Q.all(dfds.map(dfd => dfd.promise)).then(writeBodyDfd.resolve);
const timeout = setTimeout(() => {
// give some additional information when we time out
writeBodyDfd.reject({
message: "Timed out rendering.",
// `timeRemaining` is how long we waited before timing out
timeWaited: timeRemaining,
elements: rendered.map(val => {
if (val === ELEMENT_ALREADY_WRITTEN) {
return 'W'; // written
} else if (val === ELEMENT_PENDING) {
return 'P'; // not rendered
} else {
return 'R'; // rendered, not yet written
}
}),
});
}, timeRemaining);
// Don't leave dead timers hanging around.
writeBodyDfd.promise.then(() => {
clearTimeout(timeout);
//writeBody ran successfully, sweet
retval.resolve();
});
return retval.promise;
}
|
javascript
|
{
"resource": ""
}
|
q58829
|
writeElements
|
validation
|
function writeElements(res, elements) {
// Pick up where we left off.
var start = RLS().nextElement||(RLS().nextElement=0);
for (var i = start; i < elements.length; RLS().nextElement = ++i){
// If we haven't rendered the next element yet, we're done.
if (elements[i] === ELEMENT_PENDING) break;
// Got one!
writeElement(res, elements[i], i);
// Free for GC.
elements[i] = ELEMENT_ALREADY_WRITTEN;
if (PageUtil.PageConfig.get('isFragment')) continue;
if (RLS().haveBootstrapped) {
// We've already bootstrapped, so we can immediately tell the
// client controller to wake the new element we just sent.
wakeElementRange(res, i, i);
} else if (i === elements.length - 1) {
// Page didn't emit `<TheFold/>`. Now we're done.
// This wakes everything up through `i`.
bootstrapClient(res, i);
}
}
// It may be a while before we render the next element, so if we just
// wrote anything let's send it down right away.
if (i !== start) flushRes(res);
}
|
javascript
|
{
"resource": ""
}
|
q58830
|
makeStandard
|
validation
|
function makeStandard(standardize, fn){
return function(){
return standardize(fn.apply(null, [].slice.call(arguments)));
}
}
|
javascript
|
{
"resource": ""
}
|
q58831
|
validation
|
function (state, title, url) {
var win = this.win;
if (this.canClientNavigate()) {
win.history.pushState(state, title, url);
} else {
this.navigationWindow().location.href = url;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q58832
|
validation
|
function (state, title, url) {
var win = this.win;
if (this.canClientNavigate()) {
win.history.replaceState(state, title, url);
} else if (url !== this.currentUrl()) {
// On browsers that don't support history navigation, only want to
// replace state if the URL is actually changing. Otherwise we're
// in for a potential infinite refresh loop.
this.navigationWindow().location.replace(url);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q58833
|
writeClientBootstrapFile
|
validation
|
function writeClientBootstrapFile(outputDir, opts) {
const outputFile = outputDir + "/entry.js";
fs.writeFileSync(outputFile, `
import reactServer from "react-server";
import routes from "./routes_client";
if (typeof window !== "undefined") {
window.__setReactServerBase = (path) => {
__webpack_public_path__ = path;
window.__reactServerBase = path;
}
}
window.rfBootstrap = () => {
reactServer.logging.setLevel('main', ${JSON.stringify(opts.logLevel)});
reactServer.logging.setLevel('time', ${JSON.stringify(opts.timingLogLevel)});
reactServer.logging.setLevel('gauge', ${JSON.stringify(opts.gaugeLogLevel)});
new reactServer.ClientController({routes}).init();
}`
);
return outputFile;
}
|
javascript
|
{
"resource": ""
}
|
q58834
|
errorInterceptor
|
validation
|
function errorInterceptor (level, msg, meta) {
if (meta instanceof Error) {
meta = {error: meta};
} else if (meta && meta.status && meta.response) {
meta = {error: meta};
}
if (_.isPlainObject(meta)) {
// allow {error: <someError>} as a valid `meta`
meta = _.mapValues(meta, normalizeError);
}
return meta;
}
|
javascript
|
{
"resource": ""
}
|
q58835
|
normalizeError
|
validation
|
function normalizeError (err) {
if (err instanceof Error) {
return _.pickBy({
message: err.message,
stack: err.stack,
}, val => !_.isEmpty(val));
}
if (err && err.status && err.response) {
// this is probably a superagent error response. we definitely don't
// want to log the whole thing
return {
response: {
status: err.status,
responseText: _.truncate(_.trimStart(err.response ? err.response.text : "<no response body>"), 200),
},
}
}
return err;
}
|
javascript
|
{
"resource": ""
}
|
q58836
|
wrapLogger
|
validation
|
function wrapLogger(getLoggerForConfig, opts) {
var mainLogger = getLoggerForConfig('main', opts)
, timeLogger = getLoggerForConfig('time', opts)
, gaugeLogger = getLoggerForConfig('gauge', opts)
, classifyTime = makeTimeClassifier(opts)
, classifyGauge = makeGaugeClassifier(opts)
// These are methods that are exposed on the primary logger.
// They just dispatch to appropriate log levels on secondary loggers.
mainLogger.time = (token, ms, opts) => timeLogger [classifyTime (ms, opts)](token, {ms });
mainLogger.gauge = (token, val, opts) => gaugeLogger[classifyGauge(val, opts)](token, {val});
// Expose these.
mainLogger.timeLogger = timeLogger;
mainLogger.gaugeLogger = gaugeLogger;
// This is just a convenience wrapper around the `time` method.
mainLogger.timer = (token, opts) => {
var t0 = new Date // For use by `timer.stop`.
, tt = t0 // For use by `timer.tick`.
, nt = 0 // Number of times `tick` has been called.
, ct = 0 // For storing return values.
return {
// The `stop` method logs the total elapsed time since
// timer creation.
stop: () => (mainLogger.time(token, ct = new Date - t0, opts), ct),
// The `tick` method logs the time elapsed since the
// last call to `tick` (or since timer creation). A
// tick may be named. If a name is not passed in the
// number of times `tick` has been called on this
// timer will be used. Don't mix named and un-named
// ticks.
tick: (name) => {
var now = new Date
name || (name = `tick_${nt++}`);
mainLogger.time(`${token}.${name}`, ct=now-tt, opts);
tt = now;
return ct
},
};
}
return mainLogger;
}
|
javascript
|
{
"resource": ""
}
|
q58837
|
makeThresholdsSieve
|
validation
|
function makeThresholdsSieve(options, defaults) {
if (!options) options = {};
// Pre-apply defaults.
Object.keys(defaults).forEach(key => options[key] || (options[key] = defaults[key]));
return (key, overrides) => {
if (overrides && overrides[key] !== void 0) return overrides[key];
return options[key];
}
}
|
javascript
|
{
"resource": ""
}
|
q58838
|
merge_objs
|
validation
|
function merge_objs(source,target) {
for (var k in source) { if (source.hasOwnProperty(k)) {
target[k] = source[k]; // TODO: does this need to be recursive for our purposes?
}}
return target;
}
|
javascript
|
{
"resource": ""
}
|
q58839
|
check_chain_group_scripts_ready
|
validation
|
function check_chain_group_scripts_ready(chain_group) {
var any_scripts_ready = false;
for (var i=0; i<chain_group.scripts.length; i++) {
if (chain_group.scripts[i].ready && chain_group.scripts[i].exec_trigger) {
any_scripts_ready = true;
chain_group.scripts[i].exec_trigger();
chain_group.scripts[i].exec_trigger = null;
}
}
return any_scripts_ready;
}
|
javascript
|
{
"resource": ""
}
|
q58840
|
create_script_load_listener
|
validation
|
function create_script_load_listener(elem,registry_item,flag,onload) {
elem.onload = elem.onreadystatechange = function() {
if ((elem.readyState && elem.readyState != "complete" && elem.readyState != "loaded") || registry_item[flag]) return;
elem.onload = elem.onreadystatechange = null;
onload();
};
}
|
javascript
|
{
"resource": ""
}
|
q58841
|
script_executed
|
validation
|
function script_executed(registry_item) {
registry_item.ready = registry_item.finished = true;
for (var i=0; i<registry_item.finished_listeners.length; i++) {
registry_item.finished_listeners[i]();
}
registry_item.ready_listeners = [];
registry_item.finished_listeners = [];
}
|
javascript
|
{
"resource": ""
}
|
q58842
|
request_script
|
validation
|
function request_script(chain_opts,script_obj,registry_item,onload,preload_this_script) {
// setTimeout() "yielding" prevents some weird race/crash conditions in older browsers
setTimeout(function(){
var script, src = script_obj.real_src, xhr;
// don't proceed until `append_to` is ready to append to
if ("item" in append_to) { // check if `append_to` ref is still a live node list
if (!append_to[0]) { // `append_to` node not yet ready
// try again in a little bit -- note: will re-call the anonymous function in the outer setTimeout, not the parent `request_script()`
setTimeout(arguments.callee,25);
return;
}
// reassign from live node list ref to pure node ref -- avoids nasty IE bug where changes to DOM invalidate live node lists
append_to = append_to[0];
}
script = document.createElement("script");
if (script_obj.type) script.type = script_obj.type;
if (script_obj.charset) script.charset = script_obj.charset;
if (script_obj.crossOrigin) script.crossOrigin = script_obj.crossOrigin;
// should preloading be used for this script?
if (preload_this_script) {
// real script preloading?
if (real_preloading) {
if (chain_opts[_Debug]) log_msg("start script preload: "+src);
registry_item.elem = script;
if (explicit_preloading) { // explicit preloading (aka, Zakas' proposal)
script.preload = true;
script.onpreload = onload;
}
else {
script.onreadystatechange = function(){
if (script.readyState == "loaded") onload();
};
}
script.src = src;
// NOTE: no append to DOM yet, appending will happen when ready to execute
}
// This is the ultimate fallback in React Server. The
// "cache-preloading" option in stock LABjs doesn't work in
// modern Chrome, so... this is our last best hope. If you're
// configured for splitJsLoadFromExecution then you'd better
// have xhr access to your scripts! They need to either be on
// the same domain or have CORS headers.
else if (chain_opts[_UseCORSXHR] || (src.indexOf(root_domain) == 0 && chain_opts[_UseLocalXHR])) {
xhr = new XMLHttpRequest(); // note: IE never uses XHR (it supports true preloading), so no more need for ActiveXObject fallback for IE <= 7
if (chain_opts[_Debug]) log_msg("start script preload (xhr): "+src);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4) {
xhr.onreadystatechange = function(){}; // fix a memory leak in IE
registry_item.text = xhr.responseText + "\n//@ sourceURL=" + src; // http://blog.getfirebug.com/2009/08/11/give-your-eval-a-name-with-sourceurl/
onload();
}
};
xhr.open("GET",src);
xhr.send();
}
// as a last resort, use cache-preloading
else {
if (chain_opts[_Debug]) log_msg("start script preload (cache): "+src);
script.type = "text/cache-script";
create_script_load_listener(script,registry_item,"ready",function() {
append_to.removeChild(script);
onload();
});
script.src = src;
append_to.insertBefore(script,append_to.firstChild);
}
}
// use async=false for ordered async? parallel-load-serial-execute http://wiki.whatwg.org/wiki/Dynamic_Script_Execution_Order
else if (script_ordered_async) {
if (chain_opts[_Debug]) log_msg("start script load (ordered async): "+src);
script.async = false;
create_script_load_listener(script,registry_item,"finished",onload);
script.src = src;
append_to.insertBefore(script,append_to.firstChild);
}
// otherwise, just a normal script element
else {
if (chain_opts[_Debug]) log_msg("start script load: "+src);
create_script_load_listener(script,registry_item,"finished",onload);
script.src = src;
append_to.insertBefore(script,append_to.firstChild);
}
},0);
}
|
javascript
|
{
"resource": ""
}
|
q58843
|
execute_preloaded_script
|
validation
|
function execute_preloaded_script(chain_opts,script_obj,registry_item) {
var script;
function preload_execute_finished() {
if (script != null) { // make sure this only ever fires once
script = null;
script_executed(registry_item);
}
}
if (registry[script_obj.src].finished) return;
if (!chain_opts[_AllowDuplicates]) registry[script_obj.src].finished = true;
script = registry_item.elem || document.createElement("script");
if (script_obj.type) script.type = script_obj.type;
if (script_obj.charset) script.charset = script_obj.charset;
if (script_obj.crossOrigin) script.crossOrigin = script_obj.crossOrigin;
create_script_load_listener(script,registry_item,"finished",preload_execute_finished);
// script elem was real-preloaded
if (registry_item.elem) {
registry_item.elem = null;
}
// script was XHR preloaded
else if (registry_item.text) {
script.onload = script.onreadystatechange = null; // script injection doesn't fire these events
script.text = registry_item.text;
}
// script was cache-preloaded
else {
script.src = script_obj.real_src;
}
append_to.insertBefore(script,append_to.firstChild);
// manually fire execution callback for injected scripts, since events don't fire
if (registry_item.text) {
preload_execute_finished();
}
}
|
javascript
|
{
"resource": ""
}
|
q58844
|
do_script
|
validation
|
function do_script(chain_opts,script_obj,chain_group,preload_this_script) {
var registry_item,
registry_items,
ready_cb = function(){ script_obj.ready_cb(script_obj,function(){ execute_preloaded_script(chain_opts,script_obj,registry_item); }); },
finished_cb = function(){ script_obj.finished_cb(script_obj,chain_group); }
;
script_obj.src = canonical_uri(script_obj.src,chain_opts[_BasePath]);
script_obj.real_src = script_obj.src +
// append cache-bust param to URL?
(chain_opts[_CacheBust] ? ((/\?.*$/.test(script_obj.src) ? "&_" : "?_") + ~~(Math.random()*1E9) + "=") : "")
;
if (!registry[script_obj.src]) registry[script_obj.src] = {items:[],finished:false};
registry_items = registry[script_obj.src].items;
// allowing duplicates, or is this the first recorded load of this script?
if (chain_opts[_AllowDuplicates] || registry_items.length == 0) {
registry_item = registry_items[registry_items.length] = {
ready:false,
finished:false,
ready_listeners:[ready_cb],
finished_listeners:[finished_cb]
};
request_script(chain_opts,script_obj,registry_item,
// which callback type to pass?
(
(preload_this_script) ? // depends on script-preloading
function(){
registry_item.ready = true;
for (var i=0; i<registry_item.ready_listeners.length; i++) {
registry_item.ready_listeners[i]();
}
registry_item.ready_listeners = [];
} :
function(){ script_executed(registry_item); }
),
// signal if script-preloading should be used or not
preload_this_script
);
}
else {
registry_item = registry_items[0];
if (registry_item.finished) {
finished_cb();
}
else {
registry_item.finished_listeners.push(finished_cb);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q58845
|
validation
|
function(){
registry_item.ready = true;
for (var i=0; i<registry_item.ready_listeners.length; i++) {
registry_item.ready_listeners[i]();
}
registry_item.ready_listeners = [];
}
|
javascript
|
{
"resource": ""
}
|
|
q58846
|
chain_script_ready
|
validation
|
function chain_script_ready(script_obj,exec_trigger) {
if (chain_opts[_Debug]) log_msg("script preload finished: "+script_obj.real_src);
script_obj.ready = true;
script_obj.exec_trigger = function() {
if (chain_opts[_Debug]) log_msg("script execute start: "+script_obj.real_src);
exec_trigger();
}
advance_exec_cursor(); // will only check for 'ready' scripts to be executed
}
|
javascript
|
{
"resource": ""
}
|
q58847
|
chain_script_executed
|
validation
|
function chain_script_executed(script_obj,chain_group) {
if (chain_opts[_Debug]) log_msg("script execution finished: "+script_obj.real_src);
script_obj.ready = script_obj.finished = true;
script_obj.exec_trigger = null;
// check if chain group is all finished
for (var i=0; i<chain_group.scripts.length; i++) {
if (!chain_group.scripts[i].finished) return;
}
// chain_group is all finished if we get this far
chain_group.finished = true;
advance_exec_cursor();
}
|
javascript
|
{
"resource": ""
}
|
q58848
|
advance_exec_cursor
|
validation
|
function advance_exec_cursor() {
if (chain_is_corked) return;
while (exec_cursor < chain.length) {
if (is_func(chain[exec_cursor])) {
if (chain_opts[_Debug]) log_msg("$LAB.wait() executing: "+chain[exec_cursor]);
try { chain[exec_cursor++](); } catch (err) {
if (chain_opts[_Debug]) log_error("$LAB.wait() error caught: ",err);
}
continue;
}
else if (!chain[exec_cursor].finished) {
if (check_chain_group_scripts_ready(chain[exec_cursor])) continue;
break;
}
exec_cursor++;
}
// we've reached the end of the chain (so far)
if (exec_cursor == chain.length) {
scripts_currently_loading = false;
group = false;
}
}
|
javascript
|
{
"resource": ""
}
|
q58849
|
init_script_chain_group
|
validation
|
function init_script_chain_group() {
if (!group || !group.scripts) {
chain.push(group = {scripts:[],finished:true});
}
}
|
javascript
|
{
"resource": ""
}
|
q58850
|
validation
|
function(){
if (arguments.length > 0) {
for (var i=0; i<arguments.length; i++) {
chain.push(arguments[i]);
}
group = chain[chain.length-1];
}
else group = false;
advance_exec_cursor();
return chainedAPI;
}
|
javascript
|
{
"resource": ""
}
|
|
q58851
|
build
|
validation
|
function build() {
console.log('Creating an optimized production build...');
webpack(config).run((err) => {
if (err) {
console.error('Failed to create a production build. Reason:');
console.error(err.message || err);
process.exit(1);
}
console.log(chalk.green('Compiled successfully.'));
console.log(`The ${chalk.cyan('dist')} folder is ready to be deployed.`);
console.log();
});
}
|
javascript
|
{
"resource": ""
}
|
q58852
|
findLogPath
|
validation
|
function findLogPath(appName, fileName) {
fileName = fileName || 'log.log';
var userData = appName ? null : utils.getUserData();
appName = appName || getAppName();
var homeDir = os.homedir ? os.homedir() : process.env.HOME;
var dir;
switch (process.platform) {
case 'darwin': {
dir = prepareDir(homeDir, 'Library', 'Logs', appName)
.or(userData)
.or(homeDir, 'Library', 'Application Support', appName)
.result;
break;
}
case 'win32': {
dir = prepareDir(userData)
.or(process.env.APPDATA, appName)
.or(homeDir, 'AppData', 'Roaming', appName)
.result;
break;
}
default: {
dir = prepareDir(userData)
.or(process.env.XDG_CONFIG_HOME, appName)
.or(homeDir, '.config', appName)
.or(process.env.XDG_DATA_HOME, appName)
.or(homeDir, '.local', 'share', appName)
.result;
break;
}
}
if (dir) {
return path.join(dir, fileName);
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q58853
|
format
|
validation
|
function format(msg, formatter, electronLog, removeStyles) {
removeStyles = removeStyles !== undefined ? removeStyles : false;
if (typeof formatter === 'function') {
return formatter(msg, electronLog);
}
var date = new Date(msg.date || Date.now());
var variables = msg.variables;
var result = formatter;
for (var i in variables) {
if (!variables.hasOwnProperty(i)) continue;
result = result.replace('{' + i + '}', variables[i]);
}
result = result
.replace('{level}', msg.level)
.replace('{text}', stringifyArray(msg.data))
.replace('{y}', String(date.getFullYear()))
.replace('{m}', pad(date.getMonth() + 1))
.replace('{d}', pad(date.getDate()))
.replace('{h}', pad(date.getHours()))
.replace('{i}', pad(date.getMinutes()))
.replace('{s}', pad(date.getSeconds()))
.replace('{ms}', pad(date.getMilliseconds(), 3))
.replace('{z}', formatTimeZone(date.getTimezoneOffset()));
if (removeStyles) {
result = result.replace(/%c/g, '');
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q58854
|
loadPackageName
|
validation
|
function loadPackageName() {
var packageFile;
try {
if (require.main.filename) {
packageFile = find(path.dirname(require.main.filename));
}
} catch (e) {
packageFile = null;
}
if (!packageFile && process.resourcesPath) {
packageFile = find(path.join(process.resourcesPath, 'app.asar'));
var electronModule = path.join('node_modules', 'electron', 'package.json');
if (packageFile && packageFile.indexOf(electronModule) !== -1) {
packageFile = null;
}
}
if (!packageFile) {
packageFile = find(process.cwd());
}
if (!packageFile) {
return null;
}
var content = fs.readFileSync(packageFile, 'utf-8');
var packageData = JSON.parse(content);
//noinspection JSUnresolvedVariable
return packageData ? packageData.productName || packageData.name : false;
}
|
javascript
|
{
"resource": ""
}
|
q58855
|
generateTypedocDocs
|
validation
|
function generateTypedocDocs(typedocDocsDir) {
const publicApiConfigFile = path.resolve(__dirname, '../src/ng5-slider/lib/public_api.json');
const publicApiConfig = JSON.parse(fs.readFileSync(publicApiConfigFile, { encoding: 'utf8' }));
const files = publicApiConfig.exports
.map(exportDef => path.resolve(__dirname, `../src/ng5-slider/lib/${exportDef.file}.ts`));
const themeDir = path.resolve(__dirname, '../typedoc-theme');
// HACK: When Typedoc finda a README.md file, it uses it to generate content for the index page of documentation
// This is not very helpful, as it repeats the same stuff that's already shown on Github and NPM
// So instead, replace the README.md with our own file
const apiDocsReadmeFile = path.resolve(__dirname, '../typedoc-theme/README.md');
utils.copyReadmeMd(apiDocsReadmeFile);
const app = new typedoc.Application({
module: 'commonjs',
target: 'es6',
includeDeclarations: false,
experimentalDecorators: true,
excludeExternals: true,
theme: themeDir
});
app.generateDocs(files, typedocDocsDir);
// HACK: restore the README.md to original
const mainReadmeFile = path.resolve(__dirname, '../README.md');
utils.copyReadmeMd(mainReadmeFile);
}
|
javascript
|
{
"resource": ""
}
|
q58856
|
generateComponent
|
validation
|
function generateComponent(typedocHtmlFile, relativeTypedocHtmlFile, demoAppDocsModuleDir) {
const directory = path.dirname(relativeTypedocHtmlFile);
mkdirp.sync(path.join(demoAppDocsModuleDir, directory));
const fileName = path.basename(relativeTypedocHtmlFile);
const componentHtmlFileName = fileName.replace(/\.html$/, '.component.html');
const componentHtmlFile = path.join(demoAppDocsModuleDir, directory, componentHtmlFileName);
const typedocHtmlFileContent = fs.readFileSync(typedocHtmlFile, { encoding: 'utf8' });
const escapedHtmlFileContent = fixRouterFragments(fixReadmeMdLinks(escapeHtmlForAngular(typedocHtmlFileContent)));
fs.writeFileSync(componentHtmlFile, escapedHtmlFileContent, { encoding: 'utf8' });
const componentFileName = fileName.replace(/\.html$/, '.component');
const componentTsFileName = componentFileName + '.ts';
const componentTsFile = path.join(demoAppDocsModuleDir, directory, componentTsFileName);
const componentName = generateComponentName(fileName);
const componentTsFileContent = `import { Component } from '@angular/core';
@Component({
templateUrl: './${componentHtmlFileName}'
})
export class ${componentName} { }
`;
fs.writeFileSync(componentTsFile, componentTsFileContent, { encoding: 'utf8' });
// Return metadata for generating module file
return {
name: componentName,
file: path.join(directory, componentFileName),
route: relativeTypedocHtmlFile // route is based on original file name
};
}
|
javascript
|
{
"resource": ""
}
|
q58857
|
generateComponentName
|
validation
|
function generateComponentName(fileName) {
const bareName = fileName.replace(/\.html$/, '').replace(/[._]/g, '');
return bareName.charAt(0).toUpperCase() + bareName.substr(1) + 'Component';
}
|
javascript
|
{
"resource": ""
}
|
q58858
|
generateModuleFile
|
validation
|
function generateModuleFile(componentsMetadata, demoAppDocsModuleDir) {
const imports = componentsMetadata
.map(componentMetadata => `import { ${componentMetadata.name} } from './${componentMetadata.file}';`)
.join('\n');
const components = componentsMetadata
.map(componentMetadata => ` ${componentMetadata.name},`)
.join('\n');
const routes = componentsMetadata
.map(componentMetadata => ` { path: 'docs/${componentMetadata.route}', component: ${componentMetadata.name} },`)
.join('\n');
const moduleTsFileContents = `import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
${imports}
const routes: Routes = [
{ path: 'docs', component: IndexComponent }, // always start with index
${routes}
];
@NgModule({
imports: [
RouterModule.forChild(routes),
],
declarations: [
${components}
],
exports: [
${components}
]
})
export class DocsModule { }
`;
const moduleTsFile = path.join(demoAppDocsModuleDir, 'docs.module.ts');
fs.writeFileSync(moduleTsFile, moduleTsFileContents, { encoding: 'utf8' });
}
|
javascript
|
{
"resource": ""
}
|
q58859
|
generatePackageJson
|
validation
|
function generatePackageJson() {
const mainFile = path.resolve(__dirname, '../package.json');
const libTemplateFile = path.resolve(__dirname, '../src/ng5-slider/package.json.template');
const libFile = path.resolve(__dirname, '../src/ng5-slider/package.json');
const libTemplateConfig = JSON.parse(fs.readFileSync(libTemplateFile, { encoding: 'utf8' }));
const mainConfig = JSON.parse(fs.readFileSync(mainFile, { encoding: 'utf8' }));
let libConfig = {};
for (let key of libTemplateConfig.keysToCopyFromMainPackageJson) {
libConfig[key] = mainConfig[key];
}
libConfig.dependencies = {};
for (let dependency of libTemplateConfig.dependenciesToCopyFromMainPackageJson) {
libConfig.dependencies[dependency] = mainConfig.dependencies[dependency];
}
libConfig.peerDependencies = {};
for (let dependency of libTemplateConfig.dependenciesToCopyAsPeerDependenciesFromMainPackageJson) {
libConfig.peerDependencies[dependency] = mainConfig.dependencies[dependency];
}
libConfig = Object.assign({}, libConfig, libTemplateConfig, libConfig);
delete libConfig.keysToCopyFromMainPackageJson;
delete libConfig.dependenciesToCopyFromMainPackageJson;
delete libConfig.dependenciesToCopyAsPeerDependenciesFromMainPackageJson;
for (let dependency of libTemplateConfig.dependenciesToCopyFromMainPackageJson) {
libConfig.ngPackage.whitelistedNonPeerDependencies.push(dependency);
}
const prettyPrintedLibConfig = JSON.stringify(libConfig, null, 2);
fs.writeFileSync(libFile, prettyPrintedLibConfig, { encoding: 'utf8' });
}
|
javascript
|
{
"resource": ""
}
|
q58860
|
generatePublicApiTs
|
validation
|
function generatePublicApiTs() {
const configFile = path.resolve(__dirname, '../src/ng5-slider/lib/public_api.json');
const tsFile = path.resolve(__dirname, '../src/ng5-slider/lib/public_api.ts');
const config = JSON.parse(fs.readFileSync(configFile, { encoding: 'utf8' }));
let tsFileContent = '';
for (let exportDef of config.exports) {
if (exportDef.what instanceof Array) {
const whats = exportDef.what.join(', ');
tsFileContent += `export { ${whats} } from '${exportDef.file}';\n`;
} else {
tsFileContent += `export ${exportDef.what} from '${exportDef.file}';\n`;
}
}
fs.writeFileSync(tsFile, tsFileContent, {encoding: 'utf8'});
}
|
javascript
|
{
"resource": ""
}
|
q58861
|
readdirRecursivelySync
|
validation
|
function readdirRecursivelySync(dir) {
let results = [];
const list = fs.readdirSync(dir);
for (let file of list) {
file = path.resolve(dir, file);
const stat = fs.statSync(file);
if (stat && stat.isDirectory()) {
results = results.concat(readdirRecursivelySync(file));
} else {
results.push(file);
}
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
q58862
|
copyReadmeMd
|
validation
|
function copyReadmeMd(sourceReadmeMd) {
const libReadmeFile = path.resolve(__dirname, '../src/ng5-slider/README.md');
const sourceReadme = fs.readFileSync(sourceReadmeMd, { encoding: 'utf8'});
fs.writeFileSync(libReadmeFile, sourceReadme, {encoding: 'utf8'});
}
|
javascript
|
{
"resource": ""
}
|
q58863
|
generateTemplate
|
validation
|
function generateTemplate(templateFile, snippetsDir) {
const titleTemplateFile = templateFile.replace('.template.html', '.title-template.html');
const outputTemplateFile = templateFile.replace('.template.html', '.html');
const codeFile = templateFile.replace('.template.html', '.ts');
const styleFile = templateFile.replace('.template.html', '.scss');
const titleTemplateFileContent = fs.readFileSync(path.resolve(snippetsDir, titleTemplateFile), { encoding: 'utf8' });
const templateFileContent = fs.readFileSync(path.resolve(snippetsDir, templateFile), { encoding: 'utf8' });
const templateTabHtml = tabHtml(path.basename(outputTemplateFile), templateFileContent, 'html');
let codeFileContent = fs.readFileSync(path.resolve(snippetsDir, codeFile), { encoding: 'utf8' });
// The only modification to the source file is to remove the @local prefix from slider import
codeFileContent = codeFileContent.replace(/@local\/ng5-slider/g, "ng5-slider");
const codeTabHtml = tabHtml(path.basename(codeFile), codeFileContent, 'typescript');
let styleTabHtml = '';
if (fs.existsSync(path.resolve(snippetsDir, styleFile))) {
const styleFileContent = fs.readFileSync(path.resolve(snippetsDir, styleFile), { encoding: 'utf8' });
styleTabHtml = tabHtml(path.basename(styleFile), styleFileContent, 'scss');
}
const outputHtmlFileContent = `<h2 class="snippet-title">${titleTemplateFileContent}</h2>
<div class="snippet-card card">
<div class="card-body">
<div class="snippet-content">
${templateFileContent}
</div>
<ngb-tabset class="snippet-code-tabset">
${codeTabHtml}
${templateTabHtml}
${styleTabHtml}
</ngb-tabset>
</div>
</div>`;
fs.writeFileSync(path.resolve(snippetsDir, outputTemplateFile), outputHtmlFileContent, { encoding: 'utf8' });
}
|
javascript
|
{
"resource": ""
}
|
q58864
|
highlight
|
validation
|
function highlight(code, lang) {
return prism.highlight(code.trim(), prism.languages[lang]);
}
|
javascript
|
{
"resource": ""
}
|
q58865
|
tabHtml
|
validation
|
function tabHtml(tabTitle, codeContent, codeLang) {
return `<ngb-tab title="${escape(tabTitle)}">
<ng-template ngbTabContent>
<pre class="language-${codeLang}"><code class="language-${codeLang}">${escapeBraces(highlight(codeContent, codeLang))}</code></pre>
</ng-template>
</ngb-tab>`;
}
|
javascript
|
{
"resource": ""
}
|
q58866
|
nomalizeScope
|
validation
|
function nomalizeScope(initialScope, node) {
let scope = getInnermostScope(initialScope, node)
while (scope && scope.block === node) {
scope = scope.upper
}
return scope
}
|
javascript
|
{
"resource": ""
}
|
q58867
|
merge
|
validation
|
function merge(x, y) {
for (const key of Object.keys(y)) {
if (typeof x[key] === "function") {
if (x[key]._handlers == null) {
const fs = [x[key], y[key]]
x[key] = dispatch.bind(null, fs)
x[key]._handlers = fs
} else {
x[key]._handlers.push(y[key])
}
} else {
x[key] = y[key]
}
}
return x
}
|
javascript
|
{
"resource": ""
}
|
q58868
|
defineVisitor
|
validation
|
function defineVisitor(context, options) {
const testInfoPrototype = {
get isStrict() {
return nomalizeScope(context.getScope(), this.node).isStrict
},
}
/**
* Check whether a given case object is full-supported on the configured node version.
* @param {{supported:string}} aCase The case object to check.
* @returns {boolean} `true` if it's supporting.
*/
function isNotSupportingVersion(aCase) {
return (
!aCase.supported ||
options.version.intersects(getSemverRange(`<${aCase.supported}`))
)
}
/**
* Define the predicate function to check whether a given case object is supported on the configured node version.
* @param {Node} node The node which is reported.
* @returns {function(aCase:{supported:string}):boolean} The predicate function.
*/
function isNotSupportingOn(node) {
return aCase =>
isNotSupportingVersion(aCase) &&
(!aCase.test || aCase.test({ node, __proto__: testInfoPrototype }))
}
return (
keywords
// Omit full-supported features and ignored features by options
// because this rule never reports those.
.filter(
keyword =>
!options.ignores.has(keyword) &&
features[keyword].cases.some(isNotSupportingVersion)
)
// Merge remaining features with overriding `context.report()`.
.reduce((visitor, keyword) => {
const { ruleId, cases } = features[keyword]
const rule = esRules[ruleId]
const thisContext = {
__proto__: context,
// Override `context.report()` then:
// - ignore if it's supported.
// - override reporting messages.
report(descriptor) {
// Set additional information.
if (descriptor.data) {
descriptor.data.version = options.version.raw
} else {
descriptor.data = { version: options.version.raw }
}
descriptor.fix = undefined
// Test and report.
const node = descriptor.node
const hitCase = cases.find(isNotSupportingOn(node))
if (hitCase) {
descriptor.messageId = hitCase.messageId
descriptor.data.supported = hitCase.supported
super.report(descriptor)
}
},
}
return merge(visitor, rule.create(thisContext))
}, {})
)
}
|
javascript
|
{
"resource": ""
}
|
q58869
|
isNotSupportingVersion
|
validation
|
function isNotSupportingVersion(aCase) {
return (
!aCase.supported ||
options.version.intersects(getSemverRange(`<${aCase.supported}`))
)
}
|
javascript
|
{
"resource": ""
}
|
q58870
|
isNotSupportingOn
|
validation
|
function isNotSupportingOn(node) {
return aCase =>
isNotSupportingVersion(aCase) &&
(!aCase.test || aCase.test({ node, __proto__: testInfoPrototype }))
}
|
javascript
|
{
"resource": ""
}
|
q58871
|
readPackageJson
|
validation
|
function readPackageJson(dir) {
const filePath = path.join(dir, "package.json")
try {
const text = fs.readFileSync(filePath, "utf8")
const data = JSON.parse(text)
if (typeof data === "object" && data !== null) {
data.filePath = filePath
return data
}
} catch (_err) {
// do nothing.
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q58872
|
get
|
validation
|
function get(option) {
if (option && option.allowModules && Array.isArray(option.allowModules)) {
return option.allowModules.map(String)
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q58873
|
getTopAssignment
|
validation
|
function getTopAssignment(leafNode) {
let node = leafNode
// Skip MemberExpressions.
while (
node.parent.type === "MemberExpression" &&
node.parent.object === node
) {
node = node.parent
}
// Check assignments.
if (!isAssignee(node)) {
return null
}
// Find the top.
while (node.parent.type === "AssignmentExpression") {
node = node.parent
}
return node
}
|
javascript
|
{
"resource": ""
}
|
q58874
|
getModuleExportsNodes
|
validation
|
function getModuleExportsNodes(scope) {
const variable = scope.set.get("module")
if (variable == null) {
return []
}
return variable.references
.map(reference => reference.identifier.parent)
.filter(
node =>
node.type === "MemberExpression" &&
getStaticPropertyName(node) === "exports"
)
}
|
javascript
|
{
"resource": ""
}
|
q58875
|
getExportsNodes
|
validation
|
function getExportsNodes(scope) {
const variable = scope.set.get("exports")
if (variable == null) {
return []
}
return variable.references.map(reference => reference.identifier)
}
|
javascript
|
{
"resource": ""
}
|
q58876
|
getLocation
|
validation
|
function getLocation(node) {
const token = sourceCode.getTokenAfter(node)
return {
start: node.loc.start,
end: token.loc.end,
}
}
|
javascript
|
{
"resource": ""
}
|
q58877
|
enforceModuleExports
|
validation
|
function enforceModuleExports() {
const globalScope = context.getScope()
const exportsNodes = getExportsNodes(globalScope)
const assignList = batchAssignAllowed
? createAssignmentList(getModuleExportsNodes(globalScope))
: []
for (const node of exportsNodes) {
// Skip if it's a batch assignment.
if (
assignList.length > 0 &&
assignList.indexOf(getTopAssignment(node)) !== -1
) {
continue
}
// Report.
context.report({
node,
loc: getLocation(node),
message:
"Unexpected access to 'exports'. Use 'module.exports' instead.",
})
}
}
|
javascript
|
{
"resource": ""
}
|
q58878
|
enforceExports
|
validation
|
function enforceExports() {
const globalScope = context.getScope()
const exportsNodes = getExportsNodes(globalScope)
const moduleExportsNodes = getModuleExportsNodes(globalScope)
const assignList = batchAssignAllowed
? createAssignmentList(exportsNodes)
: []
const batchAssignList = []
for (const node of moduleExportsNodes) {
// Skip if it's a batch assignment.
if (assignList.length > 0) {
const found = assignList.indexOf(getTopAssignment(node))
if (found !== -1) {
batchAssignList.push(assignList[found])
assignList.splice(found, 1)
continue
}
}
// Report.
context.report({
node,
loc: getLocation(node),
message:
"Unexpected access to 'module.exports'. Use 'exports' instead.",
})
}
// Disallow direct assignment to `exports`.
for (const node of exportsNodes) {
// Skip if it's not assignee.
if (!isAssignee(node)) {
continue
}
// Check if it's a batch assignment.
if (batchAssignList.indexOf(getTopAssignment(node)) !== -1) {
continue
}
// Report.
context.report({
node,
loc: getLocation(node),
message:
"Unexpected assignment to 'exports'. Don't modify 'exports' itself.",
})
}
}
|
javascript
|
{
"resource": ""
}
|
q58879
|
filterNeverIgnoredFiles
|
validation
|
function filterNeverIgnoredFiles(p) {
const basedir = path.dirname(p.filePath)
const mainFilePath =
typeof p.main === "string" ? path.join(basedir, p.main) : null
return filePath =>
path.join(basedir, filePath) !== mainFilePath &&
filePath !== "package.json" &&
!NEVER_IGNORED.test(path.relative(basedir, filePath))
}
|
javascript
|
{
"resource": ""
}
|
q58880
|
normalizeValue
|
validation
|
function normalizeValue(x) {
if (Array.isArray(x)) {
return x
}
return Object.keys(x).map(pattern => ({
include: [pattern],
exclude: [],
replace: x[pattern],
}))
}
|
javascript
|
{
"resource": ""
}
|
q58881
|
createMatch
|
validation
|
function createMatch(includePatterns, excludePatterns) {
const include = includePatterns.map(pattern => new Minimatch(pattern))
const exclude = excludePatterns.map(pattern => new Minimatch(pattern))
return filePath =>
include.some(m => m.match(filePath)) &&
!exclude.some(m => m.match(filePath))
}
|
javascript
|
{
"resource": ""
}
|
q58882
|
combine
|
validation
|
function combine(converters) {
return filePath => {
for (const converter of converters) {
if (converter.match(filePath)) {
return converter.convert(filePath)
}
}
return filePath
}
}
|
javascript
|
{
"resource": ""
}
|
q58883
|
parse
|
validation
|
function parse(option) {
if (
!option ||
!option.convertPath ||
typeof option.convertPath !== "object"
) {
return null
}
const converters = []
for (const pattern of normalizeValue(option.convertPath)) {
const include = toStringArray(pattern.include)
const exclude = toStringArray(pattern.exclude)
const fromRegexp = new RegExp(String(pattern.replace[0])) //eslint-disable-line require-unicode-regexp
const toStr = String(pattern.replace[1])
converters.push({
match: createMatch(include, exclude),
convert: defineConvert(fromRegexp, toStr),
})
}
return combine(converters)
}
|
javascript
|
{
"resource": ""
}
|
q58884
|
toName
|
validation
|
function toName(type, path) {
const baseName = path.join(".")
return type === ReferenceTracker.CALL
? `${baseName}()`
: type === ReferenceTracker.CONSTRUCT
? `new ${baseName}()`
: baseName
}
|
javascript
|
{
"resource": ""
}
|
q58885
|
reportItem
|
validation
|
function reportItem(node, name, info) {
context.report({
node,
loc: node.loc,
message:
"{{name}} was deprecated since v{{version}}{{replace}}.",
data: {
name,
version: info.since,
replace: toReplaceMessage(info.replacedBy),
},
})
}
|
javascript
|
{
"resource": ""
}
|
q58886
|
get
|
validation
|
function get(option) {
if (option && option.tryExtensions && Array.isArray(option.tryExtensions)) {
return option.tryExtensions.map(String)
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q58887
|
getDefaultVersion
|
validation
|
function getDefaultVersion(filename) {
const info = getPackageJson(filename)
const nodeVersion = info && info.engines && info.engines.node
return semver.validRange(nodeVersion) || DEFAULT_VERSION
}
|
javascript
|
{
"resource": ""
}
|
q58888
|
getIgnoresEnum
|
validation
|
function getIgnoresEnum() {
return Object.keys(
OPTIONS.reduce((retv, key) => {
for (const alias of FEATURES[key].alias) {
retv[alias] = true
}
retv[key] = true
return retv
}, Object.create(null))
)
}
|
javascript
|
{
"resource": ""
}
|
q58889
|
isIgnored
|
validation
|
function isIgnored(key, ignores) {
return (
ignores.indexOf(key) !== -1 ||
FEATURES[key].alias.some(alias => ignores.indexOf(alias) !== -1)
)
}
|
javascript
|
{
"resource": ""
}
|
q58890
|
hasPattern
|
validation
|
function hasPattern(s, pattern) {
const m = pattern.exec(s)
return m != null && (m[1] || "").length % 2 === 0
}
|
javascript
|
{
"resource": ""
}
|
q58891
|
hasTrailingCommaForFunction
|
validation
|
function hasTrailingCommaForFunction(node) {
const length = node.params.length
return (
length >= 1 &&
sourceCode.getTokenAfter(node.params[length - 1]).value === ","
)
}
|
javascript
|
{
"resource": ""
}
|
q58892
|
extendsNull
|
validation
|
function extendsNull(node) {
return (
node.superClass != null &&
node.superClass.type === "Literal" &&
node.superClass.value === null
)
}
|
javascript
|
{
"resource": ""
}
|
q58893
|
report
|
validation
|
function report(node, key) {
const version = supportInfo.version
const feature = supportInfo.features[key]
if (feature.supported) {
return
}
if (!feature.supportedInStrict) {
context.report({
node,
message:
"{{feature}} {{be}} not supported yet on Node {{version}}.",
data: {
feature: feature.name,
be: feature.singular ? "is" : "are",
version,
},
})
} else if (!nomalizeScope(context.getScope(), node).isStrict) {
context.report({
node,
message:
"{{feature}} {{be}} not supported yet on Node {{version}}.",
data: {
feature: `${feature.name} in non-strict mode`,
be: feature.singular ? "is" : "are",
version,
},
})
}
}
|
javascript
|
{
"resource": ""
}
|
q58894
|
validateRegExp
|
validation
|
function validateRegExp(pattern, flags, node) {
if (typeof pattern === "string") {
if (hasPattern(pattern, REGEXP_NAMED_GROUP)) {
report(node, "regexpNamedCaptureGroups")
}
if (hasPattern(pattern, REGEXP_LOOKBEHIND)) {
report(node, "regexpLookbehind")
}
if (hasPattern(pattern, REGEXP_UNICODE_PROPERTY)) {
report(node, "regexpUnicodeProperties")
}
}
if (typeof flags === "string") {
if (flags.indexOf("y") !== -1) {
report(node, "regexpY")
}
if (flags.indexOf("u") !== -1) {
report(node, "regexpU")
}
if (flags.indexOf("s") !== -1) {
report(node, "regexpS")
}
}
}
|
javascript
|
{
"resource": ""
}
|
q58895
|
validateRegExpLiteral
|
validation
|
function validateRegExpLiteral(node) {
validateRegExp(node.regex.pattern, node.regex.flags, node)
}
|
javascript
|
{
"resource": ""
}
|
q58896
|
getFilePath
|
validation
|
function getFilePath(isModule, id, options) {
try {
return resolve.sync(id, options)
} catch (_err) {
if (isModule) {
return null
}
return path.resolve(options.basedir, id)
}
}
|
javascript
|
{
"resource": ""
}
|
q58897
|
getModuleName
|
validation
|
function getModuleName(nameOrPath) {
let end = nameOrPath.indexOf("/")
if (end !== -1 && nameOrPath[0] === "@") {
end = nameOrPath.indexOf("/", 1 + end)
}
return end === -1 ? nameOrPath : nameOrPath.slice(0, end)
}
|
javascript
|
{
"resource": ""
}
|
q58898
|
isBinFile
|
validation
|
function isBinFile(filePath, binField, basedir) {
if (!binField) {
return false
}
if (typeof binField === "string") {
return filePath === path.resolve(basedir, binField)
}
return Object.keys(binField).some(
key => filePath === path.resolve(basedir, binField[key])
)
}
|
javascript
|
{
"resource": ""
}
|
q58899
|
getExistingExtensions
|
validation
|
function getExistingExtensions(filePath) {
const basename = path.basename(filePath, path.extname(filePath))
try {
return fs
.readdirSync(path.dirname(filePath))
.filter(
filename =>
path.basename(filename, path.extname(filename)) === basename
)
.map(filename => path.extname(filename))
} catch (_error) {
return []
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.