_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2100
|
readDirectory
|
train
|
function readDirectory (srcDir) {
let srcTree = {}
const entries = fs.readdirSync(srcDir)
entries.forEach(function (entry) {
const filePath = path.join(srcDir, entry)
if (fs.lstatSync(filePath).isDirectory()) {
srcTree[entry] = readDirectory(filePath)
} else {
srcTree[entry] = fs.readFileSync(filePath, {
encoding: 'utf8'
})
}
})
return srcTree
}
|
javascript
|
{
"resource": ""
}
|
q2101
|
parseDirectory
|
train
|
function parseDirectory(dataStr) {
let currChar = '';
let directory = '';
let pos = 24;
while (currChar !== '\x1E') {
currChar = dataStr.charAt(pos);
if (currChar !== 'x1E') {
directory += currChar;
}
pos++;
if (pos > dataStr.length) {
throw new Error('Invalid record');
}
}
return directory;
}
|
javascript
|
{
"resource": ""
}
|
q2102
|
parseDirectoryEntries
|
train
|
function parseDirectoryEntries(directoryStr) {
const directoryEntries = [];
let pos = 0;
let count = 0;
while (directoryStr.length - pos >= 12) {
directoryEntries[count] = directoryStr.substring(pos, pos + 12);
pos += 12;
count++;
}
return directoryEntries;
}
|
javascript
|
{
"resource": ""
}
|
q2103
|
trimNumericField
|
train
|
function trimNumericField(input) {
while (input.length > 1 && input.charAt(0) === '0') {
input = input.substring(1);
}
return input;
}
|
javascript
|
{
"resource": ""
}
|
q2104
|
addLeadingZeros
|
train
|
function addLeadingZeros(numField, length) {
while (numField.toString().length < length) {
numField = '0' + numField.toString();
}
return numField;
}
|
javascript
|
{
"resource": ""
}
|
q2105
|
lengthInUtf8Bytes
|
train
|
function lengthInUtf8Bytes(str) {
const m = encodeURIComponent(str).match(/%[89ABab]/g);
return str.length + (m ? m.length : 0);
}
|
javascript
|
{
"resource": ""
}
|
q2106
|
utf8Substr
|
train
|
function utf8Substr(str, startInBytes, lengthInBytes) {
const strBytes = stringToByteArray(str);
const subStrBytes = [];
let count = 0;
for (let i = startInBytes; count < lengthInBytes; i++) {
subStrBytes.push(strBytes[i]);
count++;
}
return byteArrayToString(subStrBytes);
// Converts the byte array to a UTF-8 string.
// From http://stackoverflow.com/questions/1240408/reading-bytes-from-a-javascript-string?lq=1
function byteArrayToString(byteArray) {
let str = '';
for (let i = 0; i < byteArray.length; i++) {
str += byteArray[i] <= 0x7F ? byteArray[i] === 0x25 ? '%25' : // %
String.fromCharCode(byteArray[i]) : '%' + byteArray[i].toString(16).toUpperCase();
}
return decodeURIComponent(str);
}
}
|
javascript
|
{
"resource": ""
}
|
q2107
|
fetchFilePathsByType
|
train
|
function fetchFilePathsByType(distFiles, basePath, type) {
return distFiles
.filter(function(filePath) {
return new RegExp('assets/.*\\.' + type + '$').test(filePath);
})
.map(function(filePath) {
return path.join(basePath, filePath);
});
}
|
javascript
|
{
"resource": ""
}
|
q2108
|
main
|
train
|
async function main() {
const { window } = webContext();
if (window) {
await windowReadiness(window);
render(window);
bootWebWorker(window);
} else {
console.warn("No web window. Can't run browser-demo.");
}
}
|
javascript
|
{
"resource": ""
}
|
q2109
|
render
|
train
|
function render({ document }) {
console.debug("rendering");
document.querySelectorAll(".replace-with-pubcontrol").forEach(el => {
el.innerHTML = `
<div>
<h2>pubcontrol default export</h2>
<pre>${JSON.stringify(objectSchema(PubControl), null, 2)}</pre>
</div>
`;
});
}
|
javascript
|
{
"resource": ""
}
|
q2110
|
windowReadiness
|
train
|
function windowReadiness({ document }) {
if (document.readyState === "loading") {
// Loading hasn't finished yet
return new Promise((resolve, reject) =>
document.addEventListener("DOMContentLoaded", resolve)
);
}
// it's ready
}
|
javascript
|
{
"resource": ""
}
|
q2111
|
objectSchema
|
train
|
function objectSchema(obj) {
const props = Object.entries(obj).reduce(
(reduced, [key, val]) => Object.assign(reduced, { [key]: typeof val }),
{}
);
return props;
}
|
javascript
|
{
"resource": ""
}
|
q2112
|
bootWebWorker
|
train
|
function bootWebWorker({ Worker }) {
const webWorker = Object.assign(
new Worker("pubcontrol-browser-demo.webworker.js"),
{
onmessage: event => {
console.debug("Message received from worker", event.data.type, event);
}
}
);
webWorker.postMessage({
type: "Hello",
from: "browser",
content: "Hello worker. I booted you out here in pubcontrol-browser-demo."
});
const url = new URL(global.location.href);
const epcp = {
uri: url.searchParams.get("epcp.uri"),
defaultChannel: url.searchParams.get("epcp.defaultChannel")
};
if (![epcp.uri, epcp.defaultChannel].every(Boolean)) {
console.warn(
"Missing one of ?epcp.uri or ?epcp.defaultChannel query params."
);
}
webWorker.postMessage({
type: "EPCPConfiguration",
...epcp
});
}
|
javascript
|
{
"resource": ""
}
|
q2113
|
func
|
train
|
function func(ast) {
var params = list(ast["params"])
var id = ast["id"] ? to_s(ast["id"]) : ""
return "function " + id + "(" + params + ") " + to_s(ast["body"])
}
|
javascript
|
{
"resource": ""
}
|
q2114
|
parens
|
train
|
function parens(parent, child) {
if (precedence(parent) >= precedence(child))
return to_s(child);
else
return "(" + to_s(child) + ")";
}
|
javascript
|
{
"resource": ""
}
|
q2115
|
precedence
|
train
|
function precedence(ast) {
var p = PRECEDENCE[ast["type"]];
if ( _.isNumber(p) ) // represents Fixnum? I'm so sorry.
return p;
else if ( p && p.constructor === Object ) // p is a {} object
return p[ast["operator"]];
else
return 0;
}
|
javascript
|
{
"resource": ""
}
|
q2116
|
generate_exports
|
train
|
function generate_exports (module) {
// # 85
// Before module factory being invoked, mark the module as `loaded`
// so we will not execute the factory function again.
// `mod.loaded` indicates that a module has already been `require()`d
// When there are cyclic dependencies, neuron will not fail.
module.loaded = true;
// During the execution of factory,
// the reference of `module.exports` might be changed.
// But we still set the `module.exports` as `{}`,
// because the module might be `require()`d during the execution of factory
// if cyclic dependency occurs.
var exports = module.exports = {};
// TODO:
// Calculate `filename` ahead of time
var __filename
// = module.filename
= NEURON_CONF.resolve(module.id);
var __dirname = dirname(__filename);
// to keep the object mod away from the executing context of factory,
// use `factory` instead `mod.factory`,
// preventing user from fetching runtime data by 'this'
var factory = module.factory;
factory(create_require(module), exports, module, __filename, __dirname);
return module.exports;
}
|
javascript
|
{
"resource": ""
}
|
q2117
|
get_mod
|
train
|
function get_mod (parsed) {
var id = parsed.id;
// id -> '@kael/[email protected]/b'
return mods[id] || (mods[id] = {
// package scope:
s: parsed.s,
// package name: 'a'
n: parsed.n,
// package version: '1.1.0'
v: parsed.v,
// module path: '/b'
p: parsed.p,
// module id: '[email protected]/b'
id: id,
// package id: '[email protected]'
k: parsed.k,
// version map of the current module
m: {},
// loading queue
l: [],
// If there is no path, it must be a main entry.
// Actually, there will always be a path when defining a module,
// but `get_mod` method is called when a module has been required,
// and not loaded and defined.
// When we `require('foo')`, `foo` must be a main module of a package.
main: !parsed.p
// map: {Object} The map of aliases to real module id
});
}
|
javascript
|
{
"resource": ""
}
|
q2118
|
create_require
|
train
|
function create_require (env) {
function require (id) {
// `require('[email protected]')` is prohibited.
prohibit_require_id_with_version(id);
// When `require()` another module inside the factory,
// the module of depdendencies must already been created
var module = get_module(id, env, true);
return get_exports(module);
}
// @param {string} id Module identifier.
// Since 4.2.0, we only allow to asynchronously load a single module
require.async = function(id, callback) {
if (callback) {
// `require.async('[email protected]')` is prohibited
prohibit_require_id_with_version(id);
var module = get_module(id, env);
// If `require.async` a foreign module, it must be a main entry
if (!module.main) {
// Or it should be a module inside the current package
if (module.n !== env.n) {
// Otherwise, we will stop that.
return;
}
module.a = true;
}
use_module(module, callback);
}
};
// @param {string} path
require.resolve = function (path) {
return NEURON_CONF.resolve(parse_id(path, env).id);
};
return require;
}
|
javascript
|
{
"resource": ""
}
|
q2119
|
type
|
train
|
function type (prop) {
var rs = Object.prototype.toString.call(prop);
return rs.slice(8, rs.length - 1).toLowerCase();
}
|
javascript
|
{
"resource": ""
}
|
q2120
|
train
|
function () {
if (processes && processes.length > 0) {
for (var i = processes.length - 1; i >= 0; i--) {
processes[i].kill();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2121
|
defaultStrategy
|
train
|
function defaultStrategy(projectDir, builder, cb)
{
const pkg = fs.realpathSync(INSTALLER_PACKAGE);
builder.buildFromPackage(pkg, projectDir, cb);
}
|
javascript
|
{
"resource": ""
}
|
q2122
|
customStrategyInPlace
|
train
|
function customStrategyInPlace(projectDir, builder, cb)
{
const installerDir = path.resolve(projectDir, "node_modules", "@deskpro", INSTALLER_PACKAGE_NAME);
const customInstallerTarget = path.resolve(installerDir, "src", "settings");
shelljs.rm('-rf', customInstallerTarget);
const copyOptions = { overwrite: true, expand: true, dot: true };
function onCustomInstallerFilesReady (err) {
builder.buildFromSource(installerDir, projectDir);
cb();
}
let customInstallerSrc = path.resolve(projectDir, "src", "installer");
customInstallerSrc = fs.realpathSync(customInstallerSrc);
copy(customInstallerSrc, customInstallerTarget, copyOptions, onCustomInstallerFilesReady);
}
|
javascript
|
{
"resource": ""
}
|
q2123
|
customStrategy
|
train
|
function customStrategy(projectDir, builder, cb)
{
const dest = builder.getTargetDestination(projectDir);
shelljs.rm('-rf', dest);
const copyOptions = { overwrite: true, expand: true, dot: true };
const onCustomInstallerFilesReady = function (err) {
builder.buildFromSource(dest, projectDir);
cb();
};
const onInstallerFilesReady = function (err) {
if (err) {
cb(err);
return;
}
let customInstallerSrc = path.resolve(projectDir, "src", "installer");
customInstallerSrc = fs.realpathSync(customInstallerSrc);
const customInstallerTarget = path.resolve(dest, "src", "settings");
copy(customInstallerSrc, customInstallerTarget, copyOptions, onCustomInstallerFilesReady);
};
let installerDir = path.resolve(projectDir, "node_modules", "@deskpro", INSTALLER_PACKAGE_NAME);
installerDir = fs.realpathSync(installerDir);
copy(installerDir, dest, copyOptions, onInstallerFilesReady);
}
|
javascript
|
{
"resource": ""
}
|
q2124
|
train
|
function (projectDir)
{
"use strict";
const packageJson = readPackageJson(projectDir);
const extracted = extractVendors(packageJson);
return extracted.filter(function (packageName) { return startsWith(packageName, '@deskpro/'); });
}
|
javascript
|
{
"resource": ""
}
|
|
q2125
|
getCurrentValue
|
train
|
function getCurrentValue(stream, key) {
if (stream._currentEvent && stream._currentEvent.type === key) {
return stream._currentEvent.value;
} else {
var names = keyNames[key];
if (!names) {
return stream[key];
}
var VALUE,
valueHandler = function(value) {
VALUE = value;
};
stream[names.on](valueHandler);
stream[names.off](valueHandler);
return VALUE;
}
}
|
javascript
|
{
"resource": ""
}
|
q2126
|
train
|
function (version) {
var splitDots = version.split(".");
var nbDots = splitDots.length - 1;
if (nbDots === 0) {
return version + ".0.0";
} else if (nbDots === 1) {
return version + ".0";
} else if (nbDots === 2) {
return version;
} else {
return splitDots.slice(0, 3).join(".") + "-" + splitDots.slice(3).join(".");
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2127
|
onLauncherConnect
|
train
|
function onLauncherConnect(slaveURL) {
var browsers = attester.config["run-browser"];
if (browsers) {
if (!Array.isArray(browsers)) {
browsers = [browsers];
}
var args = [slaveURL];
for (var i = 0, l = browsers.length; i < l; i++) {
var curProcess = spawn(browsers[i], args, {
stdio: "pipe"
});
curProcess.stdout.pipe(process.stdout);
curProcess.stderr.pipe(process.stderr);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2128
|
train
|
function (options, overrides) {
let resolved = null;
if (typeof options === 'string') { //we've been give a path to a project dir or babelrc
let babelrcPath;
const stats = fs.statSync(options);
if (stats.isDirectory()) {
babelrcPath = path.join(options, '.babelrc');
} else if (stats.isFile()) {
babelrcPath = options;
}
if (babelrcPath) {
try {
const babelOptions = JSON.parse(fs.readFileSync(babelrcPath));
resolved = resolveOptions(babelOptions);
} catch (e) {
console.log(e);
}
}
} else if (typeof options === 'object') {
resolved = resolveOptions(options);
}
if (resolved) {
Object.keys(overrides).forEach(function (key) {
resolved[key] = overrides[key];
});
return resolved;
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q2129
|
train
|
function (cfg, state, n) {
cfg.args = cfg.args || {};
var phantomPath = cfg.phantomPath;
var controlScript = pathUtil.join(__dirname, '../browsers/phantomjs-control-script.js');
var args = [];
args.push(controlScript);
args.push("--auto-exit");
if (cfg.args.autoExitPolling) {
args.push("--auto-exit-polling=" + cfg.args.autoExitPolling);
}
if (typeof n == "undefined") {
n = Math.round(Math.random() * 1000) % 1000;
}
args.push("--instance-id=" + n);
args.push(cfg.slaveURL);
var phantomProcess = spawn(phantomPath, args, {
stdio: "pipe"
});
if (cfg.pipeStdOut) {
phantomProcess.stdout.pipe(process.stdout);
phantomProcess.stderr.pipe(process.stderr);
}
if (cfg.onData) {
phantomProcess.stdout.on("data", cfg.onData);
}
phantomProcess.on("exit", cfg.onExit || this.createPhantomExitCb(cfg, state, n).bind(this));
phantomProcess.on("error", cfg.onError || this.createPhantomErrorCb(cfg, state, n).bind(this));
return phantomProcess;
}
|
javascript
|
{
"resource": ""
}
|
|
q2130
|
train
|
function (cfg, state, n) {
// Node 0.8 and 0.10 differently handle spawning errors ('exit' vs 'error'), but errors that happened after
// launching the command are both handled in 'exit' callback
return function (code, signal) {
// See http://tldp.org/LDP/abs/html/exitcodes.html and http://stackoverflow.com/a/1535733/
if (code === 0 || signal == "SIGTERM" || state.resetCalled) {
return;
}
var isNotRecoverable = (code == 127 || code == 126);
if (isNotRecoverable) {
++state.erroredPhantomInstances;
var path = cfg.phantomPath;
if (code == 127) {
logger.logError("Spawn: exited with code 127. PhantomJS executable not found. Make sure to download PhantomJS and add its folder to your system's PATH, or pass the full path directly to Attester via --phantomjs-path.\nUsed command: '" + path + "'");
} else if (code == 126) {
logger.logError("Spawn: exited with code 126. Unable to execute PhantomJS. Make sure to have proper read & execute permissions set.\nUsed command: '" + path + "'");
}
checkIfAllPhantomsDied(cfg, state);
return;
}
// Now, try to recover unless retried too many times
// prepare error message
var errMsg;
if (code == 75) {
errMsg = "Spawn: PhantomJS[" + n + "] exited with code 75: unable to load attester page within specified timeout, or errors happened while loading.";
if (cfg.phantomInstances > 1) {
errMsg += " You may try decreasing the number of PhantomJS instances in attester config to avoid that problem.";
}
} else {
errMsg = "Spawn: PhantomJS[" + n + "] exited with code " + code + " and signal " + signal;
}
// check how many retries happened for this instance
var retries = state.retries;
retries[n] = (retries[n] || 0) + 1;
if (retries[n] < cfg.maxRetries) {
// log just a warning and try rebooting
logger.logWarn(errMsg);
logger.logWarn("Trying to reboot instance nr " + n + "...");
this.bootPhantom(cfg, state, n);
} else {
logger.logError(errMsg);
++state.erroredPhantomInstances;
checkIfAllPhantomsDied(cfg, state);
}
};
}
|
javascript
|
{
"resource": ""
}
|
|
q2131
|
train
|
function (cfg, state, n) {
return function (err) {
if (err.code == "ENOENT") {
logger.logError("Spawn: exited with code ENOENT. PhantomJS executable not found. Make sure to download PhantomJS and add its folder to your system's PATH, or pass the full path directly to Attester via --phantomjs-path.\nUsed command: '" + cfg.phantomPath + "'");
} else {
logger.logError("Unable to spawn PhantomJS; error code " + err.code);
}
};
}
|
javascript
|
{
"resource": ""
}
|
|
q2132
|
train
|
function () {
this.addResult = function (event) {
var fullUrl = event.homeURL + url;
http.get(fullUrl, function (response) {
var content = "";
response.on("data", function (chunk) {
content += chunk;
});
response.on("end", function () {
callback(content);
});
});
};
this.checkFinished = function () {
return false;
};
events.EventEmitter.call(this);
}
|
javascript
|
{
"resource": ""
}
|
|
q2133
|
resolvePath
|
train
|
function resolvePath (moduleName, relativePath)
{
if (! moduleName) {
return null;
}
if (! relativePath) {
return null;
}
const mainPath = require.resolve(moduleName);
if (! mainPath) {
return null;
}
const rootLocations = [];
const dirs = mainPath.split(path.sep);
let lastSegment = dirs.pop();
while (lastSegment) {
const location = dirs.concat(['package.json']).join(path.sep);
rootLocations.push(location);
lastSegment = dirs.pop();
}
for(const location of rootLocations) {
if (fs.existsSync(location)) {
const cli = path.resolve(path.dirname(location), relativePath);
if (fs.existsSync(cli)) {
return cli;
}
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q2134
|
Arguable
|
train
|
function Arguable (usage, argv, options) {
this._usage = usage
// These are the merged defintion and invocation options provided by the
// user.
this.options = options.options
// The key used to create the `Destructible`.
this.identifier = options.identifier
// We'll use this for an exit code if it is set and if we exit normally.
this.exitCode = null
// Are we running as a main module?
this.isMainModule = options.isMainModule
// Use environment `LANG` or else language of first usage definition.
this.lang = coalesce(options.lang, this._usage.language)
// Extract argument patterns from usage.
var patterns = this._usage.getPattern()
// Extract the arguments that accept values, TODO maybe call `valuable`.
this.arguable = patterns.filter(function (pattern) {
return pattern.arguable
}).map(function (pattern) {
return pattern.verbose
})
// Parse arguments and save the remaining arguments.
try {
var gotopts = getopt(patterns, argv)
} catch (error) {
this.abend(error.abend, error.context)
}
// Extract an argument end sigil and note that it was there.
if (this.terminal = argv[0] == '--') {
argv.shift()
}
// Slice and dice results into convenience structures.
this._setParameters(gotopts)
// Remaining arguments.
this.argv = argv
// Assign standard I/O provide in `options`.
this.stdout = options.stdout
this.stderr = options.stderr
this.stdin = options.stdin
// Assign pipes open to our parent.
this.pipes = options.pipes
// Set after we get our arguments.
this.scram = 0
// Called when we exit with no arguments.
this.exited = new Signal
}
|
javascript
|
{
"resource": ""
}
|
q2135
|
normalizePage
|
train
|
function normalizePage(content) {
var data = {
"head-start": [],
"head": [],
"head-end": [],
body: []
};
if (typeof content === "string") {
data.body.push(content);
} else {
["head-start", "head", "head-end", "body"].forEach(function (section) {
var sectionContent = content[section];
if (!sectionContent) {
return;
}
if (!_.isArray(sectionContent)) {
data[section].push(sectionContent);
} else {
data[section] = sectionContent;
}
});
}
return data;
}
|
javascript
|
{
"resource": ""
}
|
q2136
|
flattenHead
|
train
|
function flattenHead(obj) {
var newHead = [];
_arrayCopy(newHead, obj["head-start"]);
_arrayCopy(newHead, obj["head"]);
_arrayCopy(newHead, obj["head-end"]);
delete obj["head-start"];
delete obj["head-end"];
obj.head = newHead;
return obj;
}
|
javascript
|
{
"resource": ""
}
|
q2137
|
_arrayCopy
|
train
|
function _arrayCopy(dest, src) {
if (Array.isArray(src)) {
src.forEach(function (item) {
dest.push(item);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q2138
|
replacePath
|
train
|
function replacePath (path, keys) {
var index = 0;
function replace (_, escaped, prefix, key, capture, group, suffix, escape) {
if (escaped) {
return escaped;
}
if (escape) {
return '\\' + escape;
}
var repeat = suffix === '+' || suffix === '*';
var optional = suffix === '?' || suffix === '*';
keys.push({
name: key || index++,
delimiter: prefix || '/',
optional: optional,
repeat: repeat
});
prefix = prefix ? ('\\' + prefix) : '';
capture = escapeGroup(capture || group || '[^' + (prefix || '\\/') + ']+?');
if (repeat) {
capture = capture + '(?:' + prefix + capture + ')*';
}
if (optional) {
return '(?:' + prefix + '(' + capture + '))?';
}
// Basic parameter support.
return prefix + '(' + capture + ')';
}
return path.replace(PATH_REGEXP, replace);
}
|
javascript
|
{
"resource": ""
}
|
q2139
|
train
|
function (cb) {
if (opts.dropCollection) {
db.listCollections({name: collectionName})
.toArray(function (err, items) {
if (err) return cb(err)
if (items.length) return coll.drop(cb)
cb()
})
} else cb()
}
|
javascript
|
{
"resource": ""
}
|
|
q2140
|
split
|
train
|
function split(secret, opts) {
if (!secret || (secret && 0 === secret.length)) {
throw new TypeError('Secret cannot be empty.')
}
if ('string' === typeof secret) {
secret = Buffer.from(secret)
}
if (false === Buffer.isBuffer(secret)) {
throw new TypeError('Expecting secret to be a buffer.')
}
if (!opts || 'object' !== typeof opts) {
throw new TypeError('Expecting options to be an object.')
}
if ('number' !== typeof opts.shares) {
throw new TypeError('Expecting shares to be a number.')
}
if (!opts.shares || opts.shares < 0 || opts.shares > MAX_SHARES) {
throw new RangeError(`Shares must be 0 < shares <= ${MAX_SHARES}.`)
}
if ('number' !== typeof opts.threshold) {
throw new TypeError('Expecting threshold to be a number.')
}
if (!opts.threshold || opts.threshold < 0 || opts.threshold > opts.shares) {
throw new RangeError(`Threshold must be 0 < threshold <= ${opts.shares}.`)
}
if (!opts.random || 'function' !== typeof opts.random) {
opts.random = random
}
const hex = codec.hex(secret)
const bin = codec.bin(hex, 16)
// prepend 1 to get extra padding, we'll account for this later
const parts = codec.split('1' + bin, BIT_PADDING, 2)
for (let i = 0; i < parts.length; ++i) {
const p = points(parts[i], opts)
for (let j = 0; j < opts.shares; ++j) {
if (!scratch[j]) {
scratch[j] = p[j].x.toString(16)
}
const z = p[j].y.toString(2)
const y = scratch[j + MAX_SHARES] || ''
// y[j] = p[j][y] + y[j]
scratch[j + MAX_SHARES] = codec.pad(z) + y
}
}
for (let i = 0; i < opts.shares; ++i) {
const x = scratch[i]
const y = codec.hex(scratch[i + MAX_SHARES], BIN_ENCODING)
scratch[i] = codec.encode(x, y)
scratch[i] = Buffer.from('0' + scratch[i], 'hex')
}
const result = scratch.slice(0, opts.shares)
scratch.fill(0)
return result
}
|
javascript
|
{
"resource": ""
}
|
q2141
|
combine
|
train
|
function combine(shares) {
const chunks = []
const x = []
const y = []
const t = shares.length
for (let i = 0; i < t; ++i) {
const share = parse(shares[i])
if (-1 === x.indexOf(share.id)) {
x.push(share.id)
const bin = codec.bin(share.data, 16)
const parts = codec.split(bin, 0, 2)
for (let j = 0; j < parts.length; ++j) {
if (!y[j]) { y[j] = [] }
y[j][x.length - 1] = parts[j]
}
}
}
for (let i = 0; i < y.length; ++i) {
const p = lagrange(0, [x, y[i]])
chunks.unshift(codec.pad(p.toString(2)))
}
const string = chunks.join('')
const bin = string.slice(1 + string.indexOf('1')) // >= 0
const hex = codec.hex(bin, BIN_ENCODING)
const value = codec.decode(hex)
return Buffer.from(value)
}
|
javascript
|
{
"resource": ""
}
|
q2142
|
train
|
function(sourceWasAnError, shouldNotReconnect) {
log.error("[Endpoint] Connection closed " + (sourceWasAnError ? 'because of an error:' + sourceWasAnError : ''));
this.connected = false;
this.handshaken = false;
this.connecting = false;
if (!shouldNotReconnect) {
log.debug('onClose():: reconnecting...');
this.handshakenBackoff.reset();
this.reconnectBackoff.backoff();
} else {
log.debug('onClose():: don\'t reconnect');
this.handshakenBackoff.reset();
this.reconnectBackoff.reset();
}
this.emit('close', sourceWasAnError);
}
|
javascript
|
{
"resource": ""
}
|
|
q2143
|
train
|
function (err) {
log.error("Redis client closed " + (err ? err.message : ''));
this.connected = false;
this.emit('close', err);
this.backoff.reset();
this.backoff.backoff();
}
|
javascript
|
{
"resource": ""
}
|
|
q2144
|
train
|
function( iframe, options ) {
var sandbox = iframe.getAttribute("sandbox");
if (typeof sandbox === "string" && !sandboxAllow.test(sandbox)) {
if (options && options.force) {
iframe.removeAttribute("sandbox");
} else if (!options || options.force !== false) {
logError(sandboxMsg);
iframe.setAttribute("data-srcdoc-polyfill", sandboxMsg);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q2145
|
addAnother
|
train
|
function addAnother(schema) {
var config = {
properties: {
another: {
description: 'Add another collection? (y/n)'.magenta
}
}
};
prompt.start();
prompt.message = ' > ';
prompt.delimiter = '';
return new Promise(function(resolve, reject) {
prompt.get(config, function(err, result) {
if (err) return reject(err);
switch (result.another.toLowerCase()) {
case 'n':
return resolve({
answer: false,
schema: schema
});
case 'y':
default:
return resolve({
answer: true,
schema: schema
});
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2146
|
getCollection
|
train
|
function getCollection() {
var config = {
properties: {
collection: {
description: 'Collection name and number of rows, 5 if omitted (ex: posts 10): '.magenta,
type: 'string',
required: true
}
}
};
prompt.start();
prompt.message = ' > ';
prompt.delimiter = '';
return new Promise(function(resolve, reject) {
prompt.get(config, function(err, result) {
if (err) return reject(err);
return resolve(result.collection);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2147
|
getFields
|
train
|
function getFields(collection) {
var message = 'What fields should "' + collection + '" have?\n',
config;
config = {
properties: {
fields: {
description: message.magenta +
' Comma-separated fieldname:fieldtype pairs (ex: id:index, username:username)\n'.grey,
type: 'string',
required: true,
pattern: FIELDS_REGEXP
}
}
};
prompt.start();
prompt.message = ' >> ';
prompt.delimiter = '';
return new Promise(function(resolve, reject) {
prompt.get(config, function(err, result) {
if (err) return reject(err);
return resolve(result.fields);
});
}).then(function(input) {
return (input.match(FIELDS_REGEXP) || []).reduce(function(prev, curr) {
var parts = curr.split(':');
prev[parts[0]] = parts[1].replace(/\+/g, '}~{'); // with "+" also support name={fistName}~{lastName} concatenations
return prev;
}, {});
});
}
|
javascript
|
{
"resource": ""
}
|
q2148
|
writeJSON
|
train
|
function writeJSON(dbName, schema) {
var baseUrl = 'http://www.filltext.com/?',
promises = [],
collection;
for (collection in schema) {
var meta = schema[collection].meta,
fields = meta.fields,
url;
url = Object.keys(fields).map(function(key) {
if (fields[key][0] === '[' && fields[key].slice(-1) === ']') {
return key + '=' + fields[key];
}
return key + '={' + fields[key] + '}';
}).join('&') + '&rows=' + meta.rows;
console.log('Url for', collection, url);
(function(c) {
promises.push(fetch(baseUrl + url).then(function(response) {
return response.json();
})
.then(function(rows) {
schema[c] = rows;
}));
})(collection);
}
return Promise.all(promises).then(function() {
fs.writeFile(dbName, JSON.stringify(schema, null, 4), function(err) {
if (err) {
Promise.reject('Failed to save JSON file: ' + err);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2149
|
pauseStreams
|
train
|
function pauseStreams (streams, options) {
if (!Array.isArray(streams)) {
// Backwards-compat with old-style streams
if (!streams._readableState && streams.pipe) streams = streams.pipe(PassThrough(options))
if (!streams._readableState || !streams.pause || !streams.pipe) {
throw new Error('Only readable stream can be merged.')
}
streams.pause()
} else {
for (let i = 0, len = streams.length; i < len; i++) streams[i] = pauseStreams(streams[i], options)
}
return streams
}
|
javascript
|
{
"resource": ""
}
|
q2150
|
process
|
train
|
function process(payload) {
var batteryRaw = parseInt(payload.substr(2,2),16) % 64;
var temperatureRaw = (parseInt(payload.substr(0,3),16) >> 2) % 256;
var battery = ((batteryRaw / 34) + 1.8).toFixed(2) + "V";
var temperature = ((temperatureRaw - 80) / 2).toFixed(1) + "C";
return {
battery: battery,
temperature: temperature
};
}
|
javascript
|
{
"resource": ""
}
|
q2151
|
process
|
train
|
function process(payload) {
payload = payload.toLowerCase();
var advA48 = address.process(payload.substr(4,12));
advA48.advHeader = header.process(payload.substr(0,4));
advA48.advData = data.process(payload.substr(16));
return advA48;
}
|
javascript
|
{
"resource": ""
}
|
q2152
|
process
|
train
|
function process(data) {
var uuid = data.substr(2,2) + data.substr(0,2);
// NOTE: this is for legacy compatibility
var advertiserData = {
serviceData: {
uuid: uuid,
data: data.substr(4)
}
};
gattservices.process(advertiserData);
return advertiserData.serviceData;
}
|
javascript
|
{
"resource": ""
}
|
q2153
|
process
|
train
|
function process(advertiserData) {
var data = advertiserData.manufacturerSpecificData.data;
var cursor = 0;
// Apple sometimes includes more than one service data
while(cursor < data.length) {
var appleType = data.substr(cursor,2);
switch(appleType) {
case '01':
return; // TODO: decipher this type (one bit set in fixed length?)
case '02':
cursor = ibeacon.process(advertiserData, cursor);
break;
case '05':
cursor = airdrop.process(advertiserData, cursor);
break;
case '07':
cursor = airpods.process(advertiserData, cursor);
break;
case '08':
cursor = service.process(advertiserData, cursor); // TODO: decipher
break;
case '09':
cursor = airplay.process(advertiserData, cursor);
break;
case '0a':
cursor = airplay.process(advertiserData, cursor);
break;
case '0b':
cursor = service.process(advertiserData, cursor); // TODO: decipher
break;
case '0c':
cursor = handoff.process(advertiserData, cursor);
break;
case '10':
cursor = nearby.process(advertiserData, cursor);
break;
default:
return; // Don't trust types that haven't yet been observed
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2154
|
process
|
train
|
function process(payload) {
var addressType = parseInt(payload.substr(0,1),16);
var typeCode = payload.substr(1,1);
var length = parseInt(payload.substr(2,2),16) % 64;
var rxAdd = "public";
var txAdd = "public";
if(addressType & 0x8) {
rxAdd = "random";
}
if(addressType & 0x4) {
txAdd = "random";
}
var type;
switch(typeCode) {
case("0"):
type = TYPE0_NAME;
break;
case("1"):
type = TYPE1_NAME;
break;
case("2"):
type = TYPE2_NAME;
break;
case("3"):
type = TYPE3_NAME;
break;
case("4"):
type = TYPE4_NAME;
break;
case("5"):
type = TYPE5_NAME;
break;
case("6"):
type = TYPE6_NAME;
break;
default:
type = TYPE_UNDEFINED_NAME;
}
return { type: type,
length: length,
txAdd: txAdd,
rxAdd: rxAdd
};
}
|
javascript
|
{
"resource": ""
}
|
q2155
|
processEddystone
|
train
|
function processEddystone(advertiserData) {
var data = advertiserData.serviceData.data;
var eddystone = {};
var frameType = data.substr(0,2);
switch(frameType) {
// UID
case '00':
eddystone.type = 'UID';
eddystone.txPower = pdu.convertTxPower(data.substr(2,2));
eddystone.uid = {};
eddystone.uid.namespace = data.substr(4,20);
eddystone.uid.instance = data.substr(24,12);
break;
// URI
case '10':
eddystone.type = 'URL';
eddystone.txPower = pdu.convertTxPower(data.substr(2,2));
eddystone.url = parseSchemePrefix(data.substr(4,2));
eddystone.url += parseEncodedUrl(data.substr(6));
break;
// TLM
case '20':
eddystone.type = 'TLM';
eddystone.version = data.substr(2,2);
if(eddystone.version === '00') {
eddystone.batteryVoltage = parseInt(data.substr(4,4),16) + 'mV';
// TODO: export 8:8 fixed point representation interpreter to pdu
eddystone.temperature = parseInt(data.substr(8,4),16);
if(eddystone.temperature > 0x7fff) {
eddystone.temperature = 0x7fff - eddystone.temperature;
}
eddystone.temperature = (eddystone.temperature / 256) + 'C';
eddystone.advertisingCount = parseInt(data.substr(12,8),16);
eddystone.uptime = (parseInt(data.substr(20,8),16) / 10) + 's';
}
else if(eddystone.version === '01') {
eddystone.etlm = data.substr(4,24);
eddystone.salt = data.substr(28,4);
eddystone.mic = data.substr(32,4);
}
break;
// EID
case '30':
eddystone.type = 'EID';
eddystone.txPower = pdu.convertTxPower(data.substr(2,2));
eddystone.eid = data.substr(4,16);
break;
}
advertiserData.serviceData.eddystone = eddystone;
}
|
javascript
|
{
"resource": ""
}
|
q2156
|
parseEncodedUrl
|
train
|
function parseEncodedUrl(encodedUrl) {
var url = '';
for(var cChar = 0; cChar < (encodedUrl.length / 2); cChar++) {
var charCode = parseInt(encodedUrl.substr(cChar*2,2),16);
switch(charCode) {
case 0x00:
url += ".com/";
break;
case 0x01:
url += ".org/";
break;
case 0x02:
url += ".edu/";
break;
case 0x03:
url += ".net/";
break;
case 0x04:
url += ".info/";
break;
case 0x05:
url += ".biz/";
break;
case 0x06:
url += ".gov/";
break;
case 0x07:
url += ".com";
break;
case 0x08:
url += ".org";
break;
case 0x09:
url += ".edu";
break;
case 0x0a:
url += ".net";
break;
case 0x0b:
url += ".info";
break;
case 0x0c:
url += ".biz";
break;
case 0x0d:
url += ".gov";
break;
default:
url += String.fromCharCode(charCode);
}
}
return url;
}
|
javascript
|
{
"resource": ""
}
|
q2157
|
Identifier
|
train
|
function Identifier(type, value) {
var isValue = (value != null);
// Constructor for EUI-64
if((type == TYPE_EUI64) && isValue) {
this.type = TYPE_EUI64;
this.value = value;
}
// Constructor for RA-28
else if((type == TYPE_RA28) && isValue) {
this.type = TYPE_RA28;
this.value = value.substr(value.length - 7, 7);
}
// Constructor for ADVA-48
else if((type == TYPE_ADVA48) && isValue) {
this.type = TYPE_ADVA48;
this.value = value;
}
// Constructor for RadioPayload
else if((type = TYPE_RADIO_PAYLOAD) && isValue) {
this.type = TYPE_RADIO_PAYLOAD;
this.value = value.payload;
this.lengthBytes = value.payloadLengthBytes;
}
// Constructor for Undefined
else {
this.type = TYPE_UNDEFINED;
this.value = null;
}
}
|
javascript
|
{
"resource": ""
}
|
q2158
|
process
|
train
|
function process(data) {
var companyIdentifierCode = data.substr(2,2);
companyIdentifierCode += data.substr(0,2);
var companyName = companyIdentifierCodes.companyNames[companyIdentifierCode];
if(typeof companyName === 'undefined') {
companyName = 'Unknown';
}
// NOTE: this is for legacy compatibility
var advertiserData = {
manufacturerSpecificData: {
companyName : companyName,
companyIdentifierCode: companyIdentifierCode,
data: data.substr(4)
}
};
// Handle the unique case of AltBeacon
if(altbeacon.isAltBeacon(advertiserData)) {
altbeacon.process(advertiserData);
return advertiserData.manufacturerSpecificData;
}
// Interpret the manufacturer specific data, if possible
// Kindly respect ascending order of company identifier codes
switch(companyIdentifierCode) {
case '004c':
apple.process(advertiserData);
return advertiserData.manufacturerSpecificData;
case '00f9':
sticknfind.process(advertiserData);
return advertiserData.manufacturerSpecificData;
case '015d':
estimote.process(advertiserData);
return advertiserData.manufacturerSpecificData;
case '0274':
motsai.process(advertiserData);
return advertiserData.manufacturerSpecificData;
case '0583':
codebluecommunications.process(advertiserData);
return advertiserData.manufacturerSpecificData;
default:
return advertiserData.manufacturerSpecificData;
}
}
|
javascript
|
{
"resource": ""
}
|
q2159
|
process
|
train
|
function process(payload) {
var advAString = payload.substr(10,2);
advAString += payload.substr(8,2);
advAString += payload.substr(6,2);
advAString += payload.substr(4,2);
advAString += payload.substr(2,2);
advAString += payload.substr(0,2);
return new identifier(identifier.ADVA48, advAString);
}
|
javascript
|
{
"resource": ""
}
|
q2160
|
process
|
train
|
function process(data) {
var flags = parseInt(data, 16);
var result = [];
if(flags & 0x01) {
result.push(BIT0_NAME);
}
if(flags & 0x02) {
result.push(BIT1_NAME);
}
if(flags & 0x04) {
result.push(BIT2_NAME);
}
if(flags & 0x08) {
result.push(BIT3_NAME);
}
if(flags & 0x10) {
result.push(BIT4_NAME);
}
if(flags & 0x20) {
result.push(BIT5_NAME);
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q2161
|
process
|
train
|
function process(advertiserData) {
var data = advertiserData.manufacturerSpecificData.data;
var packetType = data.substr(0,2);
switch(packetType) {
case '01':
snfsingle.process(advertiserData);
break;
case '42':
snsmotion.process(advertiserData);
break;
default:
}
}
|
javascript
|
{
"resource": ""
}
|
q2162
|
process
|
train
|
function process(advertiserData, cursor) {
var iBeacon = {};
var data = advertiserData.manufacturerSpecificData.data;
iBeacon.uuid = data.substr(4,32);
iBeacon.major = data.substr(36,4);
iBeacon.minor = data.substr(40,4);
iBeacon.txPower = pdu.convertTxPower(data.substr(44,2));
var licenseeName = licenseeNames[iBeacon.uuid];
if(typeof licenseeName === 'undefined') {
licenseeName = 'Unknown';
}
iBeacon.licenseeName = licenseeName;
advertiserData.manufacturerSpecificData.iBeacon = iBeacon;
return cursor + 46;
}
|
javascript
|
{
"resource": ""
}
|
q2163
|
process
|
train
|
function process(advertiserData) {
var altBeacon = {};
var data = advertiserData.manufacturerSpecificData.data;
altBeacon.id = data.substr(4,40);
altBeacon.refRSSI = pdu.convertTxPower(data.substr(44,2));
altBeacon.mfgReserved = data.substr(46,2);
advertiserData.manufacturerSpecificData.altBeacon = altBeacon;
}
|
javascript
|
{
"resource": ""
}
|
q2164
|
isAltBeacon
|
train
|
function isAltBeacon(advertiserData) {
var data = advertiserData.manufacturerSpecificData.data;
var isCorrectLength = ((data.length + 6) === (LENGTH * 2));
var isCorrectCode = (data.substr(0,4) === CODE);
return isCorrectLength && isCorrectCode;
}
|
javascript
|
{
"resource": ""
}
|
q2165
|
process
|
train
|
function process(data) {
var result = '';
for(var cChar = 0; cChar < data.length; cChar += 2) {
result += String.fromCharCode(parseInt(data.substr(cChar,2),16));
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q2166
|
process
|
train
|
function process(advertiserData) {
var snfBeacon = {};
var data = advertiserData.manufacturerSpecificData.data;
snfBeacon.type = 'SnS Motion';
snfBeacon.timestamp = parseInt(pdu.reverseBytes(data.substr(2,8)),16);
snfBeacon.temperature = parseInt(data.substr(10,2),16);
if(snfBeacon.temperature > 127) {
snfBeacon.temperature = 127 - snfBeacon.temperature;
}
snfBeacon.temperature = snfBeacon.temperature / 2;
snfBeacon.temperature += (parseInt(data.substr(41,1),16)) / 4;
snfBeacon.batteryVoltage = data.substr(12,2);
snfBeacon.eventCounters = [];
snfBeacon.eventCounters.push(data.substr(26,1) + data.substr(14,2));
snfBeacon.eventCounters.push(data.substr(27,1) + data.substr(16,2));
snfBeacon.eventCounters.push(data.substr(28,1) + data.substr(18,2));
snfBeacon.eventCounters.push(data.substr(29,1) + data.substr(20,2));
snfBeacon.eventCounters.push(data.substr(30,1) + data.substr(22,2));
snfBeacon.eventCounters.push(data.substr(31,1) + data.substr(24,2));
for(var cCounter = 0; cCounter < 6; cCounter++) {
var hexStringCount = snfBeacon.eventCounters[cCounter];
snfBeacon.eventCounters[cCounter] = parseInt(hexStringCount,16);
}
snfBeacon.accelerationX = parseInt((data.substr(32,2) +
data.substr(38,1)), 16);
snfBeacon.accelerationY = parseInt((data.substr(34,2) +
data.substr(39,1)), 16);
snfBeacon.accelerationZ = parseInt((data.substr(36,2) +
data.substr(40,1)), 16);
advertiserData.manufacturerSpecificData.snfBeacon = snfBeacon;
}
|
javascript
|
{
"resource": ""
}
|
q2167
|
process
|
train
|
function process(advertiserData) {
var snfBeacon = {};
var data = advertiserData.manufacturerSpecificData.data;
snfBeacon.type = 'V2 Single Payload';
snfBeacon.id = pdu.reverseBytes(data.substr(2,16));
snfBeacon.time = parseInt(pdu.reverseBytes(data.substr(18,8)),16);
snfBeacon.scanCount = parseInt(data.substr(26,2),16) / 4;
snfBeacon.batteryVoltage = data.substr(28,2);
snfBeacon.temperature = parseInt(data.substr(30,2),16);
if(snfBeacon.temperature > 127) {
snfBeacon.temperature = 127 - snfBeacon.temperature;
}
snfBeacon.temperature += (parseInt(data.substr(26,2),16) % 4) / 4;
snfBeacon.calibration = data.substr(32,2);
snfBeacon.checksum = data.substr(34,6);
advertiserData.manufacturerSpecificData.snfBeacon = snfBeacon;
}
|
javascript
|
{
"resource": ""
}
|
q2168
|
process
|
train
|
function process(payload) {
payload = payload.toLowerCase();
var ra28 = new identifier(identifier.RA28, payload.substr(0, 7));
var eui64 = ra28.toType(identifier.EUI64);
eui64.flags = flags.process(payload.substr(7, 1));
if (payload.length === 12) {
eui64.data = data.process(payload.substr(8, 4));
}
return eui64;
}
|
javascript
|
{
"resource": ""
}
|
q2169
|
process
|
train
|
function process(advertiserData) {
var data = advertiserData.manufacturerSpecificData.data;
var packetType = data.substr(0,2);
switch(packetType) { // Update when we have manufacturer documentation
case '01':
default:
nearable.process(advertiserData);
}
}
|
javascript
|
{
"resource": ""
}
|
q2170
|
addColorScale
|
train
|
function addColorScale(name, colors, positions) {
if (colors.length !== positions.length) {
throw new Error('Invalid color scale.');
}
colorscales[name] = { colors, positions };
}
|
javascript
|
{
"resource": ""
}
|
q2171
|
renderColorScaleToCanvas
|
train
|
function renderColorScaleToCanvas(name, canvas) {
/* eslint-disable no-param-reassign */
const csDef = colorscales[name];
canvas.height = 1;
const ctx = canvas.getContext('2d');
if (Object.prototype.toString.call(csDef) === '[object Object]') {
canvas.width = 256;
const gradient = ctx.createLinearGradient(0, 0, 256, 1);
for (let i = 0; i < csDef.colors.length; ++i) {
gradient.addColorStop(csDef.positions[i], csDef.colors[i]);
}
ctx.fillStyle = gradient;
ctx.fillRect(0, 0, 256, 1);
} else if (Object.prototype.toString.call(csDef) === '[object Uint8Array]') {
canvas.width = 256;
const imgData = ctx.createImageData(256, 1);
imgData.data.set(csDef);
ctx.putImageData(imgData, 0, 0);
} else {
throw new Error('Color scale not defined.');
}
/* eslint-enable no-param-reassign */
}
|
javascript
|
{
"resource": ""
}
|
q2172
|
clear
|
train
|
function clear () {
var str = '';
for (var i = 0; i < 20; i++) {
if (Math.random() < 0.5) {
str += '\u200B';
} else {
str += ' ';
}
}
return str;
}
|
javascript
|
{
"resource": ""
}
|
q2173
|
setSizes
|
train
|
function setSizes(){
// Put the scatter plot on the left.
scatterPlot.box = {
x: 0,
y: 0,
width: div.clientWidth / 2,
height: div.clientHeight
};
// Put the bar chart on the right.
barChart.box = {
x: div.clientWidth / 2,
y: 0,
width: div.clientWidth / 2,
height: div.clientHeight
};
}
|
javascript
|
{
"resource": ""
}
|
q2174
|
path
|
train
|
function path(d) {
return line(dimensions.map(function(p) { return [position(p), y[p](d[p])]; }));
}
|
javascript
|
{
"resource": ""
}
|
q2175
|
brush
|
train
|
function brush() {
var actives = dimensions.filter(function(p) { return !y[p].brush.empty(); }),
extents = actives.map(function(p) { return y[p].brush.extent(); }),
selectedPaths = foregroundPaths.filter(function(d) {
return actives.every(function(p, i) {
return extents[i][0] <= d[p] && d[p] <= extents[i][1];
});
});
foregroundPaths.style('display', 'none');
selectedPaths.style('display', null);
model.selectedData = selectedPaths.data();
}
|
javascript
|
{
"resource": ""
}
|
q2176
|
type
|
train
|
function type(d) {
// The '+' notation parses the string as a Number.
d.sepalLength = +d.sepalLength;
d.sepalWidth = +d.sepalWidth;
return d;
}
|
javascript
|
{
"resource": ""
}
|
q2177
|
setRandomData
|
train
|
function setRandomData(data){
// Include each key with a small chance
var randomKeys = Object.keys(data[0]).filter(function(d){
return Math.random() < 0.5;
}),
// Make a copy of the objects with only the
// random keys included.
dataWithRandomKeys = data.map(function (d) {
var e = {};
randomKeys.forEach(function (key) {
e[key] = d[key];
});
return e;
}),
// Include each element with a small chance
randomSample = dataWithRandomKeys.filter(function(d){
return Math.random() < 0.1;
});
// Update the table with the random data.
table.set({
data: randomSample,
columns: randomKeys.map(function (key) {
return {
title: capitalize(key),
property: key
};
})
});
}
|
javascript
|
{
"resource": ""
}
|
q2178
|
randomString
|
train
|
function randomString() {
var possibilities = ['Frequency', 'Population', 'Alpha', 'Beta'],
i = Math.round(Math.random() * possibilities.length);
return possibilities[i];
}
|
javascript
|
{
"resource": ""
}
|
q2179
|
track
|
train
|
function track(property, thisArg){
if(!(property in trackedProperties)){
trackedProperties[property] = true;
values[property] = model[property];
Object.defineProperty(model, property, {
get: function () { return values[property]; },
set: function(newValue) {
var oldValue = values[property];
values[property] = newValue;
getListeners(property).forEach(function(callback){
callback.call(thisArg, newValue, oldValue);
});
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
q2180
|
off
|
train
|
function off(property, callback){
listeners[property] = listeners[property].filter(function (listener) {
return listener !== callback;
});
}
|
javascript
|
{
"resource": ""
}
|
q2181
|
Model
|
train
|
function Model(defaults){
// Make sure "new" is always used,
// so we can use "instanceof" to check if something is a Model.
if (!(this instanceof Model)) {
return new Model(defaults);
}
// `model` is the public API object returned from invoking `new Model()`.
var model = this,
// The internal stored values for tracked properties. { property -> value }
values = {},
// The callback functions for each tracked property. { property -> [callback] }
listeners = {},
// The set of tracked properties. { property -> true }
trackedProperties = {};
// The functional reactive "when" operator.
//
// * `properties` An array of property names (can also be a single property string).
// * `callback` A callback function that is called:
// * with property values as arguments, ordered corresponding to the properties array,
// * only if all specified properties have values,
// * once for initialization,
// * whenever one or more specified properties change,
// * on the next tick of the JavaScript event loop after properties change,
// * only once as a result of one or more synchronous changes to dependency properties.
function when(properties, callback, thisArg){
// Make sure the default `this` becomes
// the object you called `.on` on.
thisArg = thisArg || this;
// Handle either an array or a single string.
properties = (properties instanceof Array) ? properties : [properties];
// This function will trigger the callback to be invoked.
var listener = debounce(function (){
var args = properties.map(function(property){
return values[property];
});
if(allAreDefined(args)){
callback.apply(thisArg, args);
}
});
// Trigger the callback once for initialization.
listener();
// Trigger the callback whenever specified properties change.
properties.forEach(function(property){
on(property, listener);
});
// Return this function so it can be removed later with `model.cancel(listener)`.
return listener;
}
// Adds a change listener for a given property with Backbone-like behavior.
// Similar to http://backbonejs.org/#Events-on
function on(property, callback, thisArg){
thisArg = thisArg || this;
getListeners(property).push(callback);
track(property, thisArg);
}
// Gets or creates the array of listener functions for a given property.
function getListeners(property){
return listeners[property] || (listeners[property] = []);
}
// Tracks a property if it is not already tracked.
function track(property, thisArg){
if(!(property in trackedProperties)){
trackedProperties[property] = true;
values[property] = model[property];
Object.defineProperty(model, property, {
get: function () { return values[property]; },
set: function(newValue) {
var oldValue = values[property];
values[property] = newValue;
getListeners(property).forEach(function(callback){
callback.call(thisArg, newValue, oldValue);
});
}
});
}
}
// Cancels a listener returned by a call to `model.when(...)`.
function cancel(listener){
for(var property in listeners){
off(property, listener);
}
}
// Removes a change listener added using `on`.
function off(property, callback){
listeners[property] = listeners[property].filter(function (listener) {
return listener !== callback;
});
}
// Sets all of the given values on the model.
// `newValues` is an object { property -> value }.
function set(newValues){
for(var property in newValues){
model[property] = newValues[property];
}
}
// Transfer defaults passed into the constructor to the model.
set(defaults);
// Public API.
model.when = when;
model.cancel = cancel;
model.on = on;
model.off = off;
model.set = set;
}
|
javascript
|
{
"resource": ""
}
|
q2182
|
selectDimensionsAndMaterials
|
train
|
function selectDimensionsAndMaterials() {
let reverbLength = document.getElementById('reverbLengthSelect').value;
switch (reverbLength) {
case 'none':
default:
{
return {
dimensions: {
width: 0,
height: 0,
depth: 0,
},
materials: {
left: 'transparent',
right: 'transparent',
front: 'transparent',
back: 'transparent',
up: 'transparent',
down: 'transparent',
},
};
}
break;
case 'short':
{
return {
dimensions: {
width: 1.5,
height: 1.5,
depth: 1.5,
},
materials: {
left: 'uniform',
right: 'uniform',
front: 'uniform',
back: 'uniform',
up: 'uniform',
down: 'uniform',
},
};
}
break;
case 'medium':
{
return {
dimensions: {
width: 6,
height: 6,
depth: 6,
},
materials: {
left: 'uniform',
right: 'uniform',
front: 'uniform',
back: 'uniform',
up: 'uniform',
down: 'uniform',
},
};
}
break;
case 'long':
{
return {
dimensions: {
width: 24,
height: 24,
depth: 24,
},
materials: {
left: 'uniform',
right: 'uniform',
front: 'uniform',
back: 'uniform',
up: 'uniform',
down: 'uniform',
},
};
}
break;
}
}
|
javascript
|
{
"resource": ""
}
|
q2183
|
ResonanceAudio
|
train
|
function ResonanceAudio(context, options) {
// Public variables.
/**
* Binaurally-rendered stereo (2-channel) output {@link
* https://developer.mozilla.org/en-US/docs/Web/API/AudioNode AudioNode}.
* @member {AudioNode} output
* @memberof ResonanceAudio
* @instance
*/
/**
* Ambisonic (multichannel) input {@link
* https://developer.mozilla.org/en-US/docs/Web/API/AudioNode AudioNode}
* (For rendering input soundfields).
* @member {AudioNode} ambisonicInput
* @memberof ResonanceAudio
* @instance
*/
/**
* Ambisonic (multichannel) output {@link
* https://developer.mozilla.org/en-US/docs/Web/API/AudioNode AudioNode}
* (For allowing external rendering / post-processing).
* @member {AudioNode} ambisonicOutput
* @memberof ResonanceAudio
* @instance
*/
// Use defaults for undefined arguments.
if (options == undefined) {
options = {};
}
if (options.ambisonicOrder == undefined) {
options.ambisonicOrder = Utils.DEFAULT_AMBISONIC_ORDER;
}
if (options.listenerPosition == undefined) {
options.listenerPosition = Utils.DEFAULT_POSITION.slice();
}
if (options.listenerForward == undefined) {
options.listenerForward = Utils.DEFAULT_FORWARD.slice();
}
if (options.listenerUp == undefined) {
options.listenerUp = Utils.DEFAULT_UP.slice();
}
if (options.dimensions == undefined) {
options.dimensions = {};
Object.assign(options.dimensions, Utils.DEFAULT_ROOM_DIMENSIONS);
}
if (options.materials == undefined) {
options.materials = {};
Object.assign(options.materials, Utils.DEFAULT_ROOM_MATERIALS);
}
if (options.speedOfSound == undefined) {
options.speedOfSound = Utils.DEFAULT_SPEED_OF_SOUND;
}
// Create member submodules.
this._ambisonicOrder = Encoder.validateAmbisonicOrder(options.ambisonicOrder);
this._sources = [];
this._room = new Room(context, {
listenerPosition: options.listenerPosition,
dimensions: options.dimensions,
materials: options.materials,
speedOfSound: options.speedOfSound,
});
this._listener = new Listener(context, {
ambisonicOrder: options.ambisonicOrder,
position: options.listenerPosition,
forward: options.listenerForward,
up: options.listenerUp,
});
// Create auxillary audio nodes.
this._context = context;
this.output = context.createGain();
this.ambisonicOutput = context.createGain();
this.ambisonicInput = this._listener.input;
// Connect audio graph.
this._room.output.connect(this._listener.input);
this._listener.output.connect(this.output);
this._listener.ambisonicOutput.connect(this.ambisonicOutput);
}
|
javascript
|
{
"resource": ""
}
|
q2184
|
updateAngles
|
train
|
function updateAngles(xAngle, yAngle, zAngle) {
let deg2rad = Math.PI / 180;
let euler = new THREE.Euler(
xAngle * deg2rad,
yAngle * deg2rad,
zAngle * deg2rad,
'YXZ');
let matrix = new THREE.Matrix4().makeRotationFromEuler(euler);
camera.setRotationFromMatrix(matrix);
if (!audioReady)
return;
if (Date.now() - lastMatrixUpdate > 100) {
audioScene.setListenerFromMatrix(camera.matrixWorld);
}
}
|
javascript
|
{
"resource": ""
}
|
q2185
|
getCursorPosition
|
train
|
function getCursorPosition(event) {
let cursorX;
let cursorY;
let rect = htmlElement.getBoundingClientRect();
if (event.touches !== undefined) {
cursorX = event.touches[0].clientX;
cursorY = event.touches[0].clientY;
} else {
cursorX = event.clientX;
cursorY = event.clientY;
}
return {
x: cursorX - rect.left,
y: cursorY - rect.top,
};
}
|
javascript
|
{
"resource": ""
}
|
q2186
|
selectRenderingMode
|
train
|
function selectRenderingMode(event) {
if (!audioReady)
return;
switch (document.getElementById('renderingMode').value) {
case 'toa':
{
noneGain.gain.value = 0;
pannerGain.gain.value = 0;
foaGain.gain.value = 0;
toaGain.gain.value = 1;
}
break;
case 'foa':
{
noneGain.gain.value = 0;
pannerGain.gain.value = 0;
foaGain.gain.value = 1;
toaGain.gain.value = 0;
}
break;
case 'panner-node':
{
noneGain.gain.value = 0;
pannerGain.gain.value = 1;
foaGain.gain.value = 0;
toaGain.gain.value = 0;
}
break;
case 'none':
default:
{
noneGain.gain.value = 1;
pannerGain.gain.value = 0;
foaGain.gain.value = 0;
toaGain.gain.value = 0;
}
break;
}
}
|
javascript
|
{
"resource": ""
}
|
q2187
|
updatePositions
|
train
|
function updatePositions(elements) {
if (!audioReady)
return;
for (let i = 0; i < elements.length; i++) {
let x = (elements[i].x - 0.5) * dimensions.width / 2;
let y = 0;
let z = (elements[i].y - 0.5) * dimensions.depth / 2;
if (i == 0) {
pannerNode.setPosition(x, y, z);
foaSource.setPosition(x, y, z);
toaSource.setPosition(x, y, z);
} else {
audioContext.listener.setPosition(x, y, z);
foaScene.setListenerPosition(x, y, z);
toaScene.setListenerPosition(x, y, z);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q2188
|
_getCoefficientsFromMaterials
|
train
|
function _getCoefficientsFromMaterials(materials) {
// Initialize coefficients to use defaults.
let coefficients = {};
for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
if (Utils.DEFAULT_ROOM_MATERIALS.hasOwnProperty(property)) {
coefficients[property] = Utils.ROOM_MATERIAL_COEFFICIENTS[
Utils.DEFAULT_ROOM_MATERIALS[property]];
}
}
// Sanitize materials.
if (materials == undefined) {
materials = {};
Object.assign(materials, Utils.DEFAULT_ROOM_MATERIALS);
}
// Assign coefficients using provided materials.
for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
if (Utils.DEFAULT_ROOM_MATERIALS.hasOwnProperty(property) &&
materials.hasOwnProperty(property)) {
if (materials[property] in Utils.ROOM_MATERIAL_COEFFICIENTS) {
coefficients[property] =
Utils.ROOM_MATERIAL_COEFFICIENTS[materials[property]];
} else {
Utils.log('Material \"' + materials[property] + '\" on wall \"' +
property + '\" not found. Using \"' +
Utils.DEFAULT_ROOM_MATERIALS[property] + '\".');
}
} else {
Utils.log('Wall \"' + property + '\" is not defined. Default used.');
}
}
return coefficients;
}
|
javascript
|
{
"resource": ""
}
|
q2189
|
_sanitizeCoefficients
|
train
|
function _sanitizeCoefficients(coefficients) {
if (coefficients == undefined) {
coefficients = {};
}
for (let property in Utils.DEFAULT_ROOM_MATERIALS) {
if (!(coefficients.hasOwnProperty(property))) {
// If element is not present, use default coefficients.
coefficients[property] = Utils.ROOM_MATERIAL_COEFFICIENTS[
Utils.DEFAULT_ROOM_MATERIALS[property]];
}
}
return coefficients;
}
|
javascript
|
{
"resource": ""
}
|
q2190
|
_sanitizeDimensions
|
train
|
function _sanitizeDimensions(dimensions) {
if (dimensions == undefined) {
dimensions = {};
}
for (let property in Utils.DEFAULT_ROOM_DIMENSIONS) {
if (!(dimensions.hasOwnProperty(property))) {
dimensions[property] = Utils.DEFAULT_ROOM_DIMENSIONS[property];
}
}
return dimensions;
}
|
javascript
|
{
"resource": ""
}
|
q2191
|
_getDurationsFromProperties
|
train
|
function _getDurationsFromProperties(dimensions, coefficients, speedOfSound) {
let durations = new Float32Array(Utils.NUMBER_REVERB_FREQUENCY_BANDS);
// Sanitize inputs.
dimensions = _sanitizeDimensions(dimensions);
coefficients = _sanitizeCoefficients(coefficients);
if (speedOfSound == undefined) {
speedOfSound = Utils.DEFAULT_SPEED_OF_SOUND;
}
// Acoustic constant.
let k = Utils.TWENTY_FOUR_LOG10 / speedOfSound;
// Compute volume, skip if room is not present.
let volume = dimensions.width * dimensions.height * dimensions.depth;
if (volume < Utils.ROOM_MIN_VOLUME) {
return durations;
}
// Room surface area.
let leftRightArea = dimensions.width * dimensions.height;
let floorCeilingArea = dimensions.width * dimensions.depth;
let frontBackArea = dimensions.depth * dimensions.height;
let totalArea = 2 * (leftRightArea + floorCeilingArea + frontBackArea);
for (let i = 0; i < Utils.NUMBER_REVERB_FREQUENCY_BANDS; i++) {
// Effective absorptive area.
let absorbtionArea =
(coefficients.left[i] + coefficients.right[i]) * leftRightArea +
(coefficients.down[i] + coefficients.up[i]) * floorCeilingArea +
(coefficients.front[i] + coefficients.back[i]) * frontBackArea;
let meanAbsorbtionArea = absorbtionArea / totalArea;
// Compute reverberation using Eyring equation [1].
// [1] Beranek, Leo L. "Analysis of Sabine and Eyring equations and their
// application to concert hall audience and chair absorption." The
// Journal of the Acoustical Society of America, Vol. 120, No. 3.
// (2006), pp. 1399-1399.
durations[i] = Utils.ROOM_EYRING_CORRECTION_COEFFICIENT * k * volume /
(-totalArea * Math.log(1 - meanAbsorbtionArea) + 4 *
Utils.ROOM_AIR_ABSORPTION_COEFFICIENTS[i] * volume);
}
return durations;
}
|
javascript
|
{
"resource": ""
}
|
q2192
|
_computeReflectionCoefficients
|
train
|
function _computeReflectionCoefficients(absorptionCoefficients) {
let reflectionCoefficients = [];
for (let property in Utils.DEFAULT_REFLECTION_COEFFICIENTS) {
if (Utils.DEFAULT_REFLECTION_COEFFICIENTS
.hasOwnProperty(property)) {
// Compute average absorption coefficient (per wall).
reflectionCoefficients[property] = 0;
for (let j = 0; j < Utils.NUMBER_REFLECTION_AVERAGING_BANDS; j++) {
let bandIndex = j + Utils.ROOM_STARTING_AVERAGING_BAND;
reflectionCoefficients[property] +=
absorptionCoefficients[property][bandIndex];
}
reflectionCoefficients[property] /=
Utils.NUMBER_REFLECTION_AVERAGING_BANDS;
// Convert absorption coefficient to reflection coefficient.
reflectionCoefficients[property] =
Math.sqrt(1 - reflectionCoefficients[property]);
}
}
return reflectionCoefficients;
}
|
javascript
|
{
"resource": ""
}
|
q2193
|
_computeDistanceOutsideRoom
|
train
|
function _computeDistanceOutsideRoom(distance) {
// We apply a linear ramp from 1 to 0 as the source is up to 1m outside.
let gain = 1;
if (distance > Utils.EPSILON_FLOAT) {
gain = 1 - distance / Utils.SOURCE_MAX_OUTSIDE_ROOM_DISTANCE;
// Clamp gain between 0 and 1.
gain = Math.max(0, Math.min(1, gain));
}
return gain;
}
|
javascript
|
{
"resource": ""
}
|
q2194
|
validateJSonStructure
|
train
|
function validateJSonStructure(filePath, cb) {
fs.readFile(filePath, function(err, data) {
if (err) {
return cb(err);
}
try {
var jsonObject = JSON.parse(data);
cb(null, jsonObject);
} catch (e) {
cb('Invalid JSON file: ' + path.basename(filePath));
}
});
}
|
javascript
|
{
"resource": ""
}
|
q2195
|
validateMetadata
|
train
|
function validateMetadata(metadataPath, cb) {
validateJSonStructure(metadataPath, function(err, metadataObject) {
if (err) {
cb(err, null);
} else {
cb(null, metadataObject.files);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q2196
|
validateForm
|
train
|
function validateForm(form, cb) {
async.series([function(callback) {
fs.exists(form, function(exists) {
if (exists) {
callback(null);
} else {
callback('File ' + path.basename(form) + ' referenced by metadata.json does not exists');
}
});
},
function(callback) {
validateJSonStructure(form, callback);
}
], function(err, data) {
cb(err, data);
});
}
|
javascript
|
{
"resource": ""
}
|
q2197
|
validate
|
train
|
function validate(archiveDirectory, strict, cb) {
// Root validation checks
fs.readdir(archiveDirectory, function(err, files) {
if (err) {
return cb(err);
}
if (files.length < 2 || (files.length !== 2 && strict)) {
return cb('Root directory must contain exactly one metadata file and one forms directory');
}
if (files.indexOf('forms') === -1) {
return cb('A forms directory should be present in the root of the zip file');
}
if (files.indexOf('metadata.json') === -1) {
return cb('A metadata.json file must be present in the root of the zip file');
}
var metadataPath = path.join(archiveDirectory, 'metadata.json');
async.waterfall([
function(callback) {
validateMetadata(metadataPath, function(err, formFiles) {
callback(err, formFiles);
});
},
function(formFiles, callback) {
var forms = [];
_.each(formFiles, function(formFile) {
forms.push(path.join(archiveDirectory, formFile.path));
});
async.each(forms, validateForm, callback);
}
], function(err) {
cb(err);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q2198
|
resolve
|
train
|
function resolve() {
expect(arguments).to.have.length.within(
1,
4,
'Invalid arguments length when resolving an Attribute (it has to be ' +
'passed from 1 to 4 arguments)'
);
var argumentArray = Array.prototype.slice.call(arguments);
var TypedAttribute = attributes.types.ObjectAttribute;
if (arguments.length === 1 && typeof arguments[0] !== 'string') {
var attribute = objects.copy(arguments[0]);
argumentArray[0] = attribute;
expect(attribute).to.be.an(
'object',
'Invalid argument type when resolving an Attribute (it has to be an ' +
'object)'
);
if (attribute.type) {
expect(attribute.type).to.be.a(
'string',
'Invalid argument "type" when resolving an Attribute' +
(attribute.name ? ' called' + attribute.name : '') +
' (it has to be a string)'
);
try {
TypedAttribute = attributes.types.get(attribute.type);
} catch (e) {
if (e instanceof errors.AttributeTypeNotFoundError) {
TypedAttribute = attributes.types.AssociationAttribute;
attribute.entity = attribute.type;
} else {
throw e;
}
}
delete attribute.type;
}
} else {
if (arguments.length > 1) {
expect(arguments[1]).to.be.a(
'string',
'Invalid argument "type" when resolving an Attribute' +
(arguments[0] ? ' called' + arguments[0] : '') +
' (it has to be a string)'
);
try {
TypedAttribute = attributes.types.get(arguments[1]);
} catch (e) {
if (e instanceof errors.AttributeTypeNotFoundError) {
TypedAttribute = attributes.types.AssociationAttribute;
argumentArray.splice(2, 0, arguments[1]);
} else {
throw e;
}
}
argumentArray.splice(1,1);
}
}
return new (Function.prototype.bind.apply(
TypedAttribute,
[null].concat(argumentArray)
))();
}
|
javascript
|
{
"resource": ""
}
|
q2199
|
getDefaultValue
|
train
|
function getDefaultValue(entity) {
expect(arguments).to.have.length(
1,
'Invalid arguments length when getting the default value of an Attribute ' +
'to an Entity instance (it has to be given 1 argument)'
);
expect(entity).to.be.an.instanceOf(
models.Entity,
'Invalid type of argument "entity" when getting the default value of an ' +
'Attribute to an Entity instance (it has to be an Entity)'
);
if (typeof this.default === 'function') {
return this.default.call(entity);
} else {
return this.default;
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.