_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4900
|
onResError
|
train
|
function onResError (ctx, err) {
// nothing we can do here other
// than delegate to the app-level
// handler and log.
if (ctx.headerSent || ctx._finished != null) {
err.headerSent = ctx.headerSent
err.context = ctx.toJSON()
return err
}
// unset headers
if (isFn(ctx.res.getHeaderNames)) {
for (let name of ctx.res.getHeaderNames()) {
if (!ON_ERROR_HEADER_REG.test(name)) ctx.res.removeHeader(name)
}
} else { // Node < 7.7
let _headers = ctx.res._headers
if (_headers) {
// retain headers on error
for (let name of Object.keys(_headers)) {
if (!ON_ERROR_HEADER_REG.test(name)) delete _headers[name]
}
}
}
// support ENOENT to 404, default to 500
if (err.code
|
javascript
|
{
"resource": ""
}
|
q4901
|
NpmApi
|
train
|
function NpmApi(options) {
if (!(this instanceof NpmApi)) {
return new NpmApi(options);
}
Base.call(this, null, options);
this.is('npmapi');
this.use(utils.plugin());
this.use(utils.option());
|
javascript
|
{
"resource": ""
}
|
q4902
|
train
|
function () {
return this.json.weatherdata.p
|
javascript
|
{
"resource": ""
}
|
|
q4903
|
train
|
function() {
const startDate = moment.utc(this.getFirstDateInPayload());
const baseDate = startDate.clone().set('hour', 12).startOf('hour');
let firstDate = baseDate.clone();
log(`five day summary is using ${baseDate.toString()} as a starting point`);
/* istanbul ignore else */
if (firstDate.isBefore(startDate)) {
// first date is unique since we may not have data back to midday so instead we
|
javascript
|
{
"resource": ""
}
|
|
q4904
|
train
|
function (time) {
time = moment.utc(time);
if (time.isValid() === false) {
return Promise.reject(
new Error('Invalid date provided for weather lookup')
);
}
if (time.minute() > 30) {
time.add('hours', 1).startOf('hour');
} else {
time.startOf('hour');
}
log('getForecastForTime', dateToForecastISO(time));
let data = this.times[dateToForecastISO(time)] || null;
/* istanbul ignore else */
|
javascript
|
{
"resource": ""
}
|
|
q4905
|
List
|
train
|
function List (name, view) {
if (!(this instanceof List)) {
return new List(name, view);
}
this.name = name;
this.view = view;
|
javascript
|
{
"resource": ""
}
|
q4906
|
Repo
|
train
|
function Repo (name, store) {
if (!(this instanceof Repo)) {
return new Repo(name);
}
Base.call(this, store);
|
javascript
|
{
"resource": ""
}
|
q4907
|
defineModel
|
train
|
function defineModel(file) {
var object = require(file),
options = object.options || {},
modelName = object.modelName;
if (debug) {
fs.writeSync(debugFD, 'var ' + modelName + ' = Sequelize.define("' + modelName + '",\n' + util.inspect(object.attributes) + ',\n' + util.inspect(options, {depth: null}) + ');\n\n\n');
|
javascript
|
{
"resource": ""
}
|
q4908
|
defineRelation
|
train
|
function defineRelation(modelName, relationType, targetModelName, options) {
if (debug) {
fs.writeSync(debugFD, modelName + '.' + relationType + '(' + targetModelName + ', ' + util.inspect(options, {depth: null}) + ');\n\n');
|
javascript
|
{
"resource": ""
}
|
q4909
|
getFileList
|
train
|
function getFileList() {
var i, file, isOverridden = {}, files = [], customFiles, baseFiles;
baseFiles = fs.readdirSync(path.join(modelsPath, definitionDir));
customFiles = fs.readdirSync(path.join(modelsPath, definitionDirCustom));
for (i = 0; i < customFiles.length; i = i + 1) {
file = customFiles[i];
if (file.match(/\.js$/)) {
isOverridden[file] = true;
files.push('./' + path.join(definitionDirCustom, file));
}
}
|
javascript
|
{
"resource": ""
}
|
q4910
|
init
|
train
|
function init() {
var debugFile = path.join(__dirname, 'debug.js');
if (debug) {
if (fs.existsSync(debugFile)) { fs.unlinkSync(debugFile); }
debugFD = fs.openSync(debugFile, 'a');
}
|
javascript
|
{
"resource": ""
}
|
q4911
|
slackAPI
|
train
|
function slackAPI(args, err_cb) {
err_cb = err_cb || function () {};
var self = this;
var authtoken = args.token;
this.slackData = {};
this.token = '';
this.logging = true;
this.autoReconnect = true;
this.i = 0;
if (typeof args !== 'object') {
this.logging = true;
this.out('error', errors.object_arg_required);
throw new Error(errors.object_arg_required);
}
if (typeof args.logging !== 'boolean') {
this.logging = true;
this.out('error', errors.boolean_arg_required);
} else {
this.logging = args.logging;
}
if (!authtoken || typeof authtoken !== 'string' || !authtoken.match(/^([a-z]*)\-([0-9]*)\-([0-9a-zA-Z]*)/)) {
this.logging = true;
this.out('error', errors.invalid_token);
throw new Error(errors.invalid_token);
}
if (typeof args.autoReconnect !== 'boolean') {
this.autoReconnect = false;
} else {
|
javascript
|
{
"resource": ""
}
|
q4912
|
collectTransitiveDependencies
|
train
|
function collectTransitiveDependencies(
collected,
depGraph,
fromName
) {
const immediateDeps = depGraph[fromName];
if (immediateDeps) {
Object.keys(immediateDeps).forEach(toName => {
if (!collected[toName]) {
|
javascript
|
{
"resource": ""
}
|
q4913
|
convertMarkdown
|
train
|
function convertMarkdown(opts) {
return new Promise((resolve, reject) => {
marked(opts.data, {}, (err, content) => {
|
javascript
|
{
"resource": ""
}
|
q4914
|
replaceDelimiters
|
train
|
function replaceDelimiters(str, source, escape) {
var regex = cache[source] || (cache[source] = new RegExp(source, 'g'));
var match;
while ((match = regex.exec(str))) {
var prefix = str.slice(0, match.index);
var inner = (escape
|
javascript
|
{
"resource": ""
}
|
q4915
|
bitArrayToArray
|
train
|
function bitArrayToArray(bitArray) {
let resultArray = [];
for (let index = 0; index < bitArray.byteLength; index++) {
let arrayByte = bitArray.readUInt8(index);
// Skip bit operations if zero -> no bit is set
|
javascript
|
{
"resource": ""
}
|
q4916
|
arrayToBitArray
|
train
|
function arrayToBitArray(numberArray, bufferLength, destinationBuffer) {
const returnBuffer = destinationBuffer ? destinationBuffer : Buffer.alloc(bufferLength);
if (destinationBuffer) {
// Get the bufferLength from the destination buffer, if one is provided
bufferLength = destinationBuffer.byteLength;
}
const maxAllowedNumber = bufferLength * 8 - 1; // Max. allowed number is defined by the buffer size
// Fill buffer with zeros first
returnBuffer.fill(0);
// Write bits
for (let index = 0; index < numberArray.length; index++) {
// Check for valid number
const numberToWrite = numberArray[index];
|
javascript
|
{
"resource": ""
}
|
q4917
|
gnuMessage
|
train
|
function gnuMessage(message, source) {
return (source ? (source.file ?
|
javascript
|
{
"resource": ""
}
|
q4918
|
read
|
train
|
function read(model) {
var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
var mode = arguments.length <= 2 || arguments[2] === undefined ? 'read' : arguments[2];
return _columns2['default'](model).then(function (modelColumns) {
var fields = query.fields && query.fields[_type2['default'](model)];
var relations = _lodash2['default'].intersection(_all_relations2['default'](model), query.include || []);
if (fields) {
fields = _lodash2['default'].intersection(modelColumns, fields);
// ensure we always select id as the spec requires this to be present
if (!_lodash2['default'].contains(fields, 'id')) {
fields.push('id');
}
}
return model.collection().query(function (qb) {
qb = processFilter(model, qb, query.filter);
qb = processSort(model.columns, qb, query.sort);
}).fetch({
|
javascript
|
{
"resource": ""
}
|
q4919
|
related
|
train
|
function related(input, relation) {
return relation.split('.').reduce(function (input, relationSegment) {
if (_is_many2['default'](input)) {
// iterate each model and add its related models to the collection
|
javascript
|
{
"resource": ""
}
|
q4920
|
destroyRelation
|
train
|
function destroyRelation(model, relations) {
if (!model) {
throw new Error('No model provided.');
}
return _destructure2['default'](model, relations).then(function (destructured)
|
javascript
|
{
"resource": ""
}
|
q4921
|
Spring
|
train
|
function Spring(fromBody, toBody, length, coeff, weight) {
this.from = fromBody;
|
javascript
|
{
"resource": ""
}
|
q4922
|
train
|
function (pos) {
if (!pos) {
throw new Error('Body position is required');
}
var body =
|
javascript
|
{
"resource": ""
}
|
|
q4923
|
train
|
function (body) {
if (!body) { return; }
var idx = bodies.indexOf(body);
if (idx < 0) { return; }
bodies.splice(idx, 1);
|
javascript
|
{
"resource": ""
}
|
|
q4924
|
train
|
function (body1, body2, springLength, springWeight, springCoefficient) {
if (!body1 || !body2) {
throw new Error('Cannot add null spring to force simulator');
}
if (typeof springLength !== 'number') {
springLength = -1; // assume global configuration
}
var spring = new
|
javascript
|
{
"resource": ""
}
|
|
q4925
|
train
|
function (spring) {
if (!spring) { return; }
var idx = springs.indexOf(spring);
if (idx > -1) {
|
javascript
|
{
"resource": ""
}
|
|
q4926
|
create
|
train
|
function create(model) {
var params = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
if (!model) {
throw new Error('No model provided.');
}
return _destructure2['default'](model.forge(), params).then(function (destructured) {
var attributes = destructured.attributes;
var relations = destructured.relations;
return _transact2['default'](model, function (transaction) {
return model.forge(attributes).save(null, {
method: 'insert',
|
javascript
|
{
"resource": ""
}
|
q4927
|
getVersion
|
train
|
function getVersion(req) {
var version;
if (!req.version) {
if (req.headers && req.headers['accept-version']) {
version = req.headers['accept-version'];
|
javascript
|
{
"resource": ""
}
|
q4928
|
Swipe
|
train
|
function Swipe(game, model) {
var self = this;
self.DIRECTION_UP = 1;
self.DIRECTION_DOWN = 2;
self.DIRECTION_LEFT = 4;
self.DIRECTION_RIGHT = 8;
self.DIRECTION_UP_RIGHT = 16;
self.DIRECTION_UP_LEFT = 32;
self.DIRECTION_DOWN_RIGHT = 64;
self.DIRECTION_DOWN_LEFT = 128;
self.game = game;
self.model = model !== undefined ? model : null;
self.dragLength = 100;
self.diagonalDelta = 50;
self.swiping = false;
self.direction = null;
|
javascript
|
{
"resource": ""
}
|
q4929
|
createRelation
|
train
|
function createRelation(model, relationName, data) {
if (!model) {
throw new Error('No model provided.');
}
return _transact2['default'](model, function (transaction) {
var existing = _related2['default'](model, relationName).map(function (rel) {
return {
id: _id2['default'](rel),
type: _type2['default'](rel)
};
|
javascript
|
{
"resource": ""
}
|
q4930
|
update
|
train
|
function update(model) {
var params = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
if (!model) {
throw new Error('No model provided.');
}
var currentState = model.toJSON({ shallow: true });
currentState.id = String(currentState.id);
return _destructure2['default'](model, params).then(function (destructured) {
var attributes = destructured.attributes;
var relations = destructured.relations;
return _transact2['default'](model, function (transaction) {
return model.save(attributes, {
patch: true,
method: 'update',
transacting: transaction
}).tap(function (model) {
return _relate2['default'](model, relations, 'update', transaction);
}).then(function (model) {
|
javascript
|
{
"resource": ""
}
|
q4931
|
saveResource
|
train
|
function saveResource(callback) {
var self = this;
self._applyCustomDataUpdatesIfNecessary(function () {
|
javascript
|
{
"resource": ""
}
|
q4932
|
toGeoJSON
|
train
|
function toGeoJSON(json, options = Options) {
const collection = helpers.featureCollection([])
json.resourceSets[0].resources.map(result => {
// Point GeoJSON
const point = parsePoint(result)
const bbox = parseBBox(result)
let confidence = confidenceScore(bbox)
const properties = {
confidence,
authenticationResultCode: json.authenticationResultCode,
|
javascript
|
{
"resource": ""
}
|
q4933
|
error
|
train
|
function error (message) {
console.log(chalk.bgRed.white('[Error]'
|
javascript
|
{
"resource": ""
}
|
q4934
|
parseAddressComponents
|
train
|
function parseAddressComponents(components, short = Options.short) {
const results = {}
components.map(component =>
|
javascript
|
{
"resource": ""
}
|
q4935
|
parseBBox
|
train
|
function parseBBox(result) {
if (result.geometry) {
if (result.geometry.viewport) {
const viewport = result.geometry.viewport
return
|
javascript
|
{
"resource": ""
}
|
q4936
|
parsePoint
|
train
|
function parsePoint(result) {
if (result.geometry) {
if (result.geometry.location) {
const {lng,
|
javascript
|
{
"resource": ""
}
|
q4937
|
toGeoJSON
|
train
|
function toGeoJSON(json, options = Options) {
const short = options.short || Options.short
const collection = helpers.featureCollection([])
json.results.map(result => {
// Get Geometries
const point = parsePoint(result)
const bbox = parseBBox(result)
// Calculate Confidence score
const location_type = result.geometry.location_type
let confidence = confidenceScore(bbox)
if (location_type === 'ROOFTOP') { confidence = 10 }
// GeoJSON Point properties
const properties = {
confidence,
location_type,
formatted_address: result.formatted_address,
place_id: result.place_id,
types: result.types,
}
// Google
|
javascript
|
{
"resource": ""
}
|
q4938
|
toGeoJSON
|
train
|
function toGeoJSON(json, options = Options) {
const collection = featureCollection([])
collection.features =
|
javascript
|
{
"resource": ""
}
|
q4939
|
request
|
train
|
function request(url, geojsonParser, params = {}, options = utils.Options) {
// Create custom Axios instance
const instance = axios.create({})
// Remove any existing default Authorization headers
if (instance.defaults.headers.common && instance.defaults.headers.common.Authorization) { delete instance.defaults.headers.common.Authorization }
if (instance.defaults.headers.Authorization) { delete instance.defaults.headers.Authorization }
// Handle request
|
javascript
|
{
"resource": ""
}
|
q4940
|
getInThere
|
train
|
function getInThere(thing, path) {
var out = thing;
var apathy = path.split('.');
for(var i =0
|
javascript
|
{
"resource": ""
}
|
q4941
|
toGeoJSON
|
train
|
function toGeoJSON(json, options = Options) {
const languages = options.languages || Options.languages
const collection = helpers.featureCollection([])
if (json.results !== undefined) {
if (json.results.bindings !== undefined) {
json.results.bindings.map(result => {
// Standard Wikidata tags
const id = result.place.value.match(/entity\/(.+)/)[1]
const [lng, lat] = result.location.value.match(/\(([\-\.\d]+) ([\-\.\d]+)\)/).slice(1, 3).map(n => Number(n))
const distance = Number(result.distance.value)
const properties = {
id,
distance,
}
if (result.placeDescription) {
|
javascript
|
{
"resource": ""
}
|
q4942
|
train
|
function ()
{
var self = this;
// Unbind events
self.$container.off('keydown', 'input');
self.$container.off('click', '[role=remove]');
|
javascript
|
{
"resource": ""
}
|
|
q4943
|
OneSignal
|
train
|
function OneSignal(apiKey, appId, sandbox) {
// Default value for sandbox argument
if (typeof sandbox === 'undefined') {
sandbox = false;
}
/**
* The api key of Signal One
* @type {String}
*/
const API_KEY = apiKey;
/**
* The app id of Signal One
* @type {String}
*/
const APP_ID = appId;
/**
* Use sandbox certificate
* @type {String}
*/
const SANDBOX = apiKey;
/**
* Handle resolving or rejecting One Signal response
*
* @param {Object} error
* @param {Object} response
* @param {String} body
* @param {Function} reject
* @param {Function} resolve
*/
function responseHandle(error, response, body, reject, resolve) {
if (error) {
return reject(error);
}
try {
body = JSON.parse(body);
} catch (e) {
return reject(new Error('Wrong JSON Format'));
}
resolve(body);
}
/**
* Register a new device and its identifier to OneSignal and get OneSignal ID
*
* @param {String} identifier the device token
* @param {String} osType ios, android
* @return {Promise} resolve with OneSignal ID
*/
this.addDevice = function(identifier, osType) {
var deviceType = osType == 'ios' ? 0 : 1;
var options = {
method: 'POST',
url: 'https://onesignal.com/api/v1/players',
headers: {
authorization: 'Basic ' + API_KEY,
'cache-control': 'no-cache',
'content-type': 'application/json; charset=utf-8'
},
body: JSON.stringify({
app_id: APP_ID,
device_type: deviceType,
identifier: identifier,
language: 'en',
test_type: SANDBOX ? 1 : null
})
};
return new Promise(function(resolve, reject) {
request(options, function(error, response, body) {
responseHandle(error, response, body, reject, function(body) {
resolve(body.id);
});
});
});
};
/**
* Update the identifier of an existing device
*
* @param {String} oneSignalId the one signal device id
* @param {String} newIdentifier the new device token
* @return {Promise}
*/
this.editDevice = function(oneSignalId, newIdentifier) {
var options = {
method: 'PUT',
url: 'https://onesignal.com/api/v1/players/' + oneSignalId,
headers: {
authorization: 'Basic ' + API_KEY,
'cache-control': 'no-cache',
|
javascript
|
{
"resource": ""
}
|
q4944
|
responseHandle
|
train
|
function responseHandle(error, response, body, reject, resolve) {
if (error) {
return reject(error);
|
javascript
|
{
"resource": ""
}
|
q4945
|
findFirstSeparatorChar
|
train
|
function findFirstSeparatorChar(input, startPos) {
for (let i = startPos; i <
|
javascript
|
{
"resource": ""
}
|
q4946
|
getDomainIndex
|
train
|
function getDomainIndex(input) {
let index = input.indexOf(':');
|
javascript
|
{
"resource": ""
}
|
q4947
|
matchOptions
|
train
|
function matchOptions(parsedFilterData, input, contextParams = {}) {
if (contextParams.elementTypeMask !== undefined && parsedFilterData.options) {
if (parsedFilterData.options.elementTypeMask !== undefined &&
!(parsedFilterData.options.elementTypeMask & contextParams.elementTypeMask)) {
return false;
} if (parsedFilterData.options.skipElementTypeMask !== undefined &&
parsedFilterData.options.skipElementTypeMask & contextParams.elementTypeMask) {
return false;
}
}
// Domain option check
if (contextParams.domain !== undefined && parsedFilterData.options) {
if (parsedFilterData.options.domains || parsedFilterData.options.skipDomains) {
// Get the domains that should be considered
let shouldBlockDomains = parsedFilterData.options.domains.filter((domain) =>
!isThirdPartyHost(domain, contextParams.domain));
let shouldSkipDomains = parsedFilterData.options.skipDomains.filter((domain) =>
!isThirdPartyHost(domain, contextParams.domain));
//
|
javascript
|
{
"resource": ""
}
|
q4948
|
toCursor
|
train
|
function toCursor(item, index) {
const id = item.id;
|
javascript
|
{
"resource": ""
}
|
q4949
|
fromCursor
|
train
|
function fromCursor(cursor) {
cursor = unbase64(cursor);
cursor = cursor.substring(cursorPrefix.length,
|
javascript
|
{
"resource": ""
}
|
q4950
|
resolveEdge
|
train
|
function resolveEdge(item, index, queriedCursor, args = {}, source) {
if (queriedCursor) {
index = parseInt(queriedCursor.index, 10) +
|
javascript
|
{
"resource": ""
}
|
q4951
|
createEdgeInfo
|
train
|
function createEdgeInfo(resultset, offset, index) {
const limit = offset - index;
// retrieve full count from the first edge
// or default 10
let fullCount = resultset[0] &&
resultset[0].fullCount &&
parseInt(resultset[0].fullCount, 10);
if (!resultset[0]) {
fullCount = 0;
}
let hasNextPage = false;
let hasPreviousPage = false;
if (offset) {
|
javascript
|
{
"resource": ""
}
|
q4952
|
applyTTL
|
train
|
function applyTTL (cond) {
if (cond[key]) {
cond.$and || (cond.$and = []);
var a = {};
a[key] = cond[key];
cond.$and.push(a);
var b = {};
b[key] = { $gt: new Date };
|
javascript
|
{
"resource": ""
}
|
q4953
|
movePropsToBackingStore
|
train
|
function movePropsToBackingStore(instance) {
var bs = getBackingStore(instance);
var proto = Object.getPrototypeOf(instance);
var stype = proto.entityType || proto.complexType;
stype.getProperties().forEach(function(prop) {
var propName = prop.name;
if (!instance.hasOwnProperty(propName)) return;
|
javascript
|
{
"resource": ""
}
|
q4954
|
movePropDefsToProto
|
train
|
function movePropDefsToProto(proto) {
var stype = proto.entityType || proto.complexType;
var ctor = proto.constructor;
if (!ctor){
throw new Error("No type constructor for EntityType = "+stype.name);
}
addResetFn(ctor);
stype.getProperties().forEach(function(prop) {
|
javascript
|
{
"resource": ""
}
|
q4955
|
getAccessorFn
|
train
|
function getAccessorFn(bs, propName) {
return function () {
if (arguments.length == 0) {
return bs[propName];
|
javascript
|
{
"resource": ""
}
|
q4956
|
linkForInput
|
train
|
function linkForInput() {
var valTemplate = config.zValidateTemplate;
var requiredTemplate = config.zRequiredTemplate || '';
var decorator = angular.element('<span class="z-decorator"></span>');
if (attrs.zAppendTo){
angular.element(document.querySelector(attrs.zAppendTo)).append(decorator);
} else {
element.after(decorator);
}
// unwrap bound elements
decorator = decorator[0];
scope.$watch(info.getValErrs, valErrsChanged);
// update the message in the validation template
// when a validation error changes on an input control
// newValue is either a string or null (null when no bound entity)
function valErrsChanged(newValue) {
// HTML5 custom validity
// http://dev.w3.org/html5/spec-preview/constraints.html#the-constraint-validation-api
if
|
javascript
|
{
"resource": ""
}
|
q4957
|
createGetValErrs
|
train
|
function createGetValErrs(info) {
return function () {
var aspect = info.getEntityAspect();
if (aspect) {
var errs = aspect.getValidationErrors(info.propertyPath);
if (errs.length) {
return errs
|
javascript
|
{
"resource": ""
}
|
q4958
|
getIsRequired
|
train
|
function getIsRequired() {
var info = this;
if (info.isRequired !== undefined) { return info.isRequired; }
// We don't know if it is required yet.
// Once bound to the entity we can determine whether the data property is required
// Note: Not bound until *second* call to the directive's link function
// which is why you MUST call 'getIsRequired'
// inside 'valErrsChanged' rather than in the link function
var entityType = info.getType();
|
javascript
|
{
"resource": ""
}
|
q4959
|
_isList
|
train
|
function _isList(gqlTye) {
if (gqlTye instanceof GraphQLList) {
return true;
}
if (gqlTye
|
javascript
|
{
"resource": ""
}
|
q4960
|
convertToCodecDefinition
|
train
|
function convertToCodecDefinition(r, line) {
if (!line || line[0] !== 'a') return r;
var result = reRtpMap.exec(line[1]);
if (!result) return r;
// Build the codec definition
var
|
javascript
|
{
"resource": ""
}
|
q4961
|
train
|
function(rawObj, arrayInst){
// create an instance
var inst = rawObj.constructor === Model ?
rawObj : new Model(rawObj);
|
javascript
|
{
"resource": ""
}
|
|
q4962
|
train
|
function(ref, deferred, loaderErr, schema) {
if (loaderErr) { return deferred.reject(loaderErr);
|
javascript
|
{
"resource": ""
}
|
|
q4963
|
instantSearch
|
train
|
function instantSearch() {
const q = $("#searchbox").val();
if (q === '')
return;
const matcher = "/matcher?beginsWith=" + q;
const request = host + matcher;
console.debug(request);
$.getJSON(request, '', {})
.done(data => {
$("#searchbox").autocomplete({
|
javascript
|
{
"resource": ""
}
|
q4964
|
terminator
|
train
|
function terminator(sig) {
if (typeof sig === "string") {
winston.log('info', '%s: Received %s - terminating service ...',
Date(Date.now()), sig);
|
javascript
|
{
"resource": ""
}
|
q4965
|
train
|
function (config) {
var idx = new lunr.Index
idx.pipeline.add(
lunr.trimmer,
lunr.stopWordFilter,
|
javascript
|
{
"resource": ""
}
|
|
q4966
|
merge
|
train
|
function merge() {
let i = 1
, key
, val
, obj
, target
;
// make sure we don't modify source element and it's properties
// objects are passed by reference
target = clone( arguments[0] );
while (obj = arguments[i++]) {
for (key in obj) {
if ( !hasOwn(obj, key) ) {
continue;
}
val = obj[key];
if ( isObject(val) && isObject(target[key]) ){
// inception, deep merge objects
target[key] = merge(target[key], val);
} else {
let is_url = val && val.type == url;
let is_path =
|
javascript
|
{
"resource": ""
}
|
q4967
|
train
|
function() {
// call the base component's init function
UIComponent.prototype.init.apply(this, arguments);
//
|
javascript
|
{
"resource": ""
}
|
|
q4968
|
generateAccount
|
train
|
function generateAccount() {
let priKeyBytes = genPriKey();
let addressBytes = getAddressFromPriKey(priKeyBytes);
let address = getBase58CheckAddress(addressBytes);
let
|
javascript
|
{
"resource": ""
}
|
q4969
|
strToDate
|
train
|
function strToDate(str) {
var tempStrs = str.split(" ");
var dateStrs = tempStrs[0].split("-");
var year = parseInt(dateStrs[0], 10);
var month = parseInt(dateStrs[1], 10) - 1;
var day = parseInt(dateStrs[2], 10);
|
javascript
|
{
"resource": ""
}
|
q4970
|
getProgramDir
|
train
|
function getProgramDir(programFile) {
const info = programFile.query_info('standard::', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
if (info.get_is_symlink()) {
const symlinkFile
|
javascript
|
{
"resource": ""
}
|
q4971
|
fontAdded
|
train
|
function fontAdded(fontObj, url) {
function properties(obj, list) {
var moreInfo = document.createElement('table');
for (var i = 0; i < list.length; i++) {
var tr = document.createElement('tr');
var td1 = document.createElement('td');
td1.textContent = list[i];
tr.appendChild(td1);
var td2 = document.createElement('td');
td2.textContent = obj[list[i]].toString();
tr.appendChild(td2);
moreInfo.appendChild(tr);
}
return moreInfo;
}
var moreInfo = properties(fontObj, ['name', 'type']);
var fontName = fontObj.loadedName;
var font = document.createElement('div');
var name = document.createElement('span');
name.textContent = fontName;
var download = document.createElement('a');
if (url) {
url = /url\(['"]?([^\)"']+)/.exec(url);
download.href = url[1];
} else if (fontObj.data) {
url = URL.createObjectURL(new Blob([fontObj.data], {
type: fontObj.mimeType,
}));
download.href = url;
}
download.textContent = 'Download';
var logIt = document.createElement('a');
logIt.href = '';
logIt.textContent = 'Log';
logIt.addEventListener('click', function(event) {
event.preventDefault();
console.log(fontObj);
});
|
javascript
|
{
"resource": ""
}
|
q4972
|
create
|
train
|
function create(pageIndex) {
var debug = document.createElement('div');
debug.id = 'stepper' + pageIndex;
debug.setAttribute('hidden', true);
debug.className = 'stepper';
stepperDiv.appendChild(debug);
var b = document.createElement('option');
b.textContent = 'Page ' + (pageIndex + 1);
b.value = pageIndex;
stepperChooser.appendChild(b);
|
javascript
|
{
"resource": ""
}
|
q4973
|
c
|
train
|
function c(tag, textContent) {
var d = document.createElement(tag);
if (textContent) {
|
javascript
|
{
"resource": ""
}
|
q4974
|
repeatRange
|
train
|
function repeatRange(_unused, what, from, to) {
return new Array(Helpers.rand(Number(to)
|
javascript
|
{
"resource": ""
}
|
q4975
|
getRowBytesFromTransactionBase64
|
train
|
function getRowBytesFromTransactionBase64(base64Data) {
let bytesDecode = base64DecodeFromString(base64Data);
let transaction
|
javascript
|
{
"resource": ""
}
|
q4976
|
genPriKey
|
train
|
function genPriKey() {
let ec = new EC('secp256k1');
let key = ec.genKeyPair();
let priKey = key.getPrivate();
let priKeyHex = priKey.toString('hex');
while
|
javascript
|
{
"resource": ""
}
|
q4977
|
getBase58CheckAddress
|
train
|
function getBase58CheckAddress(addressBytes) {
var hash0 = SHA256(addressBytes);
var hash1 = SHA256(hash0);
var checkSum = hash1.slice(0, 4);
|
javascript
|
{
"resource": ""
}
|
q4978
|
getBase58CheckAddressFromPriKeyBase64String
|
train
|
function getBase58CheckAddressFromPriKeyBase64String(priKeyBase64String) {
var priKeyBytes = base64DecodeFromString(priKeyBase64String);
var pubBytes = getPubKeyFromPriKey(priKeyBytes);
var
|
javascript
|
{
"resource": ""
}
|
q4979
|
ECKeySign
|
train
|
function ECKeySign(hashBytes, priKeyBytes) {
let ec = new EC('secp256k1');
let key = ec.keyFromPrivate(priKeyBytes, 'bytes');
let signature = key.sign(hashBytes);
let r = signature.r;
let s = signature.s;
let id = signature.recoveryParam;
let rHex = r.toString('hex');
while (rHex.length < 64) {
rHex = "0" + rHex;
}
let sHex =
|
javascript
|
{
"resource": ""
}
|
q4980
|
SHA256
|
train
|
function SHA256(msgBytes) {
let shaObj = new jsSHA("SHA-256", "HEX");
let msgHex =
|
javascript
|
{
"resource": ""
}
|
q4981
|
register
|
train
|
function register(module, value) {
if (module in CORE_MODULES && DEBUG) {
|
javascript
|
{
"resource": ""
}
|
q4982
|
internetAvailable
|
train
|
function internetAvailable(settings) {
// Require dns-socket module from dependencies
var dns = require('dns-socket');
settings = settings || {};
return new Promise(function(resolve, reject){
// Create instance of the DNS resolver
var socket = dns({
timeout: (settings.timeout || 5000),
retries: (settings.retries || 5)
});
// Run the dns lowlevel lookup
socket.query({
questions: [{
type: 'A',
name: (settings.domainName || "google.com")
|
javascript
|
{
"resource": ""
}
|
q4983
|
ingestSVG
|
train
|
function ingestSVG(cb) {
// :NOTE: xmlMode is important to not lowercase SVG tags
// and attributes, like viewBox and clipPath
|
javascript
|
{
"resource": ""
}
|
q4984
|
svgcolor
|
train
|
function svgcolor(el, color) {
var styles = window.getComputedStyle(el, null);
var fill = styles['fill'];
var stroke = styles['stroke'];
var isFill, isStroke;
if (!fill && !stroke) {
isFill = true;
}
else {
if (fill && fill !== 'none') {
isFill = true;
}
if (stroke && stroke !== 'none') {
isStroke = true;
|
javascript
|
{
"resource": ""
}
|
q4985
|
addCamelCasedVersion
|
train
|
function addCamelCasedVersion(obj) {
const regExp = /(-[a-z])/g
const replace = str => str[1].toUpperCase()
const newObj = {}
for (const key in obj) {
|
javascript
|
{
"resource": ""
}
|
q4986
|
iterate
|
train
|
function iterate(prop, value, options) {
if (!value) return value
let convertedValue = value
let type = typeof value
if (type === 'object' && Array.isArray(value)) type = 'array'
switch (type) {
case 'object':
if (prop === 'fallbacks') {
for (const innerProp in value) {
value[innerProp] = iterate(innerProp, value[innerProp], options)
}
break
}
for (const innerProp in value) {
value[innerProp] = iterate(`${prop}-${innerProp}`, value[innerProp], options)
}
break
case 'array':
|
javascript
|
{
"resource": ""
}
|
q4987
|
Flow
|
train
|
function Flow(flowControlId) {
Duplex.call(this, { objectMode: true });
this._window = this._initialWindow = INITIAL_WINDOW_SIZE;
this._flowControlId = flowControlId;
|
javascript
|
{
"resource": ""
}
|
q4988
|
train
|
function(cfg) {
var sharingLink = _.get(cfg, 'links.sharing', {});
cfg.pluginsConfig.sharing = _.defaults(cfg.pluginsConfig.sharing || {}, {});
_.each(sharingLink, function(enabled, type) {
if (enabled != false) return;
|
javascript
|
{
"resource": ""
}
|
|
q4989
|
readLogStream
|
train
|
async function readLogStream(file, instance) {
return new Promise(resolve => {
var stream = fs.createReadStream(file, { encoding: 'utf8', highWaterMark: instance.chunkSize });
var hasStarted = false;
// Split data into chunks so we dont stall the client
stream.on('data', chunk => {
if (!hasStarted) instance.emit("parsingStarted");
hasStarted = true;
var lines = chunk.toString().split("\n");
// Pause stream until this chunk is completed to avoid spamming the thread
stream.pause();
async.each(lines, function (line, callback) {
|
javascript
|
{
"resource": ""
}
|
q4990
|
momentRandom
|
train
|
function momentRandom(end = moment(), start) {
const endTime = +moment(end);
const randomNumber = (to, from = 0) =>
Math.floor(Math.random() * (to - from) + from);
|
javascript
|
{
"resource": ""
}
|
q4991
|
ApiClient
|
train
|
function ApiClient(endpoint) {
if (endpoint.length > 0 && endpoint.slice(-1) != "/") {
endpoint += "/";
|
javascript
|
{
"resource": ""
}
|
q4992
|
SubscribeMixin
|
train
|
function SubscribeMixin(subscribe, key) {
var unsubscribe;
return {
componentDidMount: function () {
// this should never happen
if (unsubscribe) {
throw new Error('Cannot reuse a mixin.');
}
unsubscribe = subscribe(function (data) {
// by default, use the store's state as the component's state
var state = data;
// but if a key is provided, map the data to that key
if (key) {
state = {};
state[key] = data;
}
// update the component's state
this.setState(state);
}.bind(this));
|
javascript
|
{
"resource": ""
}
|
q4993
|
prepareRes
|
train
|
function prepareRes(stanza) {
var res = null;
if (stanza.is('iq') && (stanza.attr('type') == 'get' || stanza.attr('type') == 'set')) {
// TODO: When connected as a component, the from field needs to be set
// eplicitly (from = stanza.attrs.to).
res = new xmpp.Stanza('iq', { id: stanza.attr('id'),
|
javascript
|
{
"resource": ""
}
|
q4994
|
MutationSigner
|
train
|
function MutationSigner(privateKey) {
this.publicKey = ByteBuffer.wrap(privateKey.publicKey.toBuffer());
this._signer = bitcore.crypto.ECDSA().set({
|
javascript
|
{
"resource": ""
}
|
q4995
|
splitOne
|
train
|
function splitOne(str, sep) {
let index = str.indexOf(sep);
return index < 0 ? null :
|
javascript
|
{
"resource": ""
}
|
q4996
|
checkType
|
train
|
function checkType(obj, keyName) {
return obj && typeof obj === 'object' && Object.keys(obj).length
|
javascript
|
{
"resource": ""
}
|
q4997
|
StanzaError
|
train
|
function StanzaError(message, type, condition) {
Error.apply(this, arguments);
Error.captureStackTrace(this, arguments.callee);
this.name = 'StanzaError';
this.message =
|
javascript
|
{
"resource": ""
}
|
q4998
|
create
|
train
|
function create() {
function app(stanza) { app.handle(stanza); }
utils.merge(app, application);
app._stack = [];
app._filters = [];
for (var i = 0; i
|
javascript
|
{
"resource": ""
}
|
q4999
|
TransactionBuilder
|
train
|
function TransactionBuilder(apiClient) {
if (typeof apiClient.namespace === "undefined" || apiClient.namespace === null) {
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.