_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q3800
|
openExplorerinLinux
|
train
|
function openExplorerinLinux(path, callback) {
path = path || '/';
let p = spawn('xdg-open', [path]);
p.on('error',
|
javascript
|
{
"resource": ""
}
|
q3801
|
openExplorer
|
train
|
function openExplorer(path, callback) {
if (osType == 'Windows_NT') {
openExplorerinWindows(path, callback);
}
else if (osType == 'Darwin') {
|
javascript
|
{
"resource": ""
}
|
q3802
|
openExplorerinMac
|
train
|
function openExplorerinMac(path, callback) {
path = path || '/';
let p = spawn('open', [path]);
p.on('error',
|
javascript
|
{
"resource": ""
}
|
q3803
|
openExplorerinWindows
|
train
|
function openExplorerinWindows(path, callback) {
path = path || '=';
let p = spawn('explorer', [path]);
p.on('error',
|
javascript
|
{
"resource": ""
}
|
q3804
|
train
|
function(p1, p2) {
var r = {
c: 90,
A: Math.abs(p2.x - p1.x),
B: Math.abs(p2.y - p1.y)
};
var brad = Math.atan2(r.B, r.A);
r.b = this.toDegrees(brad);
// r.C =
|
javascript
|
{
"resource": ""
}
|
|
q3805
|
train
|
function(r) {
r = Object.assign(r, {
C: 90
});
r.A = r.A || 90 - r.B;
r.B = r.B || 90 - r.A;
var arad = toRadians(r.A);
// sinA = a/c
// a = c * sinA
// tanA = a/b
// a = b * tanA
r.a = r.a || (r.c ? r.c
|
javascript
|
{
"resource": ""
}
|
|
q3806
|
train
|
function(object) {
return Array.isArray(object)
|
javascript
|
{
"resource": ""
}
|
|
q3807
|
train
|
function(desired, nozzel = NOZZEL_SIZE, nozzie =
|
javascript
|
{
"resource": ""
}
|
|
q3808
|
train
|
function(desired, nozzel = NOZZEL_SIZE, nozzie
|
javascript
|
{
"resource": ""
}
|
|
q3809
|
train
|
function(msg, o) {
echo(
msg,
JSON.stringify(o.getBounds()),
|
javascript
|
{
"resource": ""
}
|
|
q3810
|
train
|
function(object, segments, axis) {
var size = object.size()[axis];
var width = size / segments;
var result = [];
for (var i = width; i <
|
javascript
|
{
"resource": ""
}
|
|
q3811
|
size
|
train
|
function size(o) {
var bbox = o.getBounds ? o.getBounds()
|
javascript
|
{
"resource": ""
}
|
q3812
|
fit
|
train
|
function fit(object, x, y, z, keep_aspect_ratio) {
var a;
if (Array.isArray(x)) {
a = x;
keep_aspect_ratio = y;
x = a[0];
y = a[1];
z = a[2];
} else {
a = [x, y, z];
}
// var c = util.centroid(object);
var size = this.size(object.getBounds());
function scale(size, value) {
if (value == 0) return 1;
return value / size;
}
var s = [scale(size.x, x),
|
javascript
|
{
"resource": ""
}
|
q3813
|
flush
|
train
|
function flush(moveobj, withobj, axis, mside, wside) {
return moveobj.translate(
|
javascript
|
{
"resource": ""
}
|
q3814
|
getDelta
|
train
|
function getDelta(size, bounds, axis, offset, nonzero) {
if (!util.isEmpty(offset) && nonzero) {
if (Math.abs(offset) < 1e-4) {
offset = 1e-4 * (util.isNegative(offset) ? -1 : 1);
}
}
|
javascript
|
{
"resource": ""
}
|
q3815
|
bisect
|
train
|
function bisect(
object,
axis,
offset,
angle,
rotateaxis,
rotateoffset,
options
) {
options = util.defaults(options, {
addRotationCenter: false
});
angle = angle || 0;
var info = util.normalVector(axis);
var bounds = object.getBounds();
var size = util.size(object);
rotateaxis =
rotateaxis ||
{
x: "y",
y: "x",
z: "x"
}[axis];
// function getDelta(axis, offset) {
// // if the offset is negative, then it's an offset from
// // the positive side of the axis
// var dist = util.isNegative(offset) ? offset = size[axis] + offset : offset;
// return util.axisApply(axis, function (i, a) {
// return bounds[0][a] + (util.isEmpty(dist) ? size[axis] / 2 : dist);
// });
// }
var
|
javascript
|
{
"resource": ""
}
|
q3816
|
stretch
|
train
|
function stretch(object, axis, distance, offset) {
var normal = {
x: [1, 0, 0],
y: [0, 1, 0],
z: [0, 0, 1]
};
var bounds = object.getBounds();
var size = util.size(object);
var cutDelta = util.getDelta(size, bounds, axis, offset, true);
|
javascript
|
{
"resource": ""
}
|
q3817
|
poly2solid
|
train
|
function poly2solid(top, bottom, height) {
if (top.sides.length == 0) {
// empty!
return new CSG$1();
}
// var offsetVector = CSG.parseOptionAs3DVector(options, "offset", [0, 0, 10]);
var offsetVector = CSG$1.Vector3D.Create(0, 0, height);
var normalVector = CSG$1.Vector3D.Create(0, 1, 0);
var polygons = [];
// bottom and top
polygons = polygons.concat(
bottom._toPlanePolygons({
translation: [0, 0, 0],
normalVector: normalVector,
flipped: !(offsetVector.z < 0)
})
);
polygons = polygons.concat(
top._toPlanePolygons({
translation: offsetVector,
normalVector: normalVector,
flipped: offsetVector.z < 0
})
);
//
|
javascript
|
{
"resource": ""
}
|
q3818
|
Hexagon
|
train
|
function Hexagon(diameter, height) {
var radius = diameter / 2;
var sqrt3 = Math.sqrt(3) / 2;
var hex = CAG.fromPoints([
[radius, 0],
[radius / 2, radius * sqrt3],
[-radius / 2, radius * sqrt3],
|
javascript
|
{
"resource": ""
}
|
q3819
|
Tube
|
train
|
function Tube(
outsideDiameter,
insideDiameter,
height,
outsideOptions,
insideOptions
) {
return
|
javascript
|
{
"resource": ""
}
|
q3820
|
train
|
function(
headDiameter,
headLength,
diameter,
length,
clearLength,
options
) {
var head = Parts.Hexagon(headDiameter, headLength);
var thread = Parts.Cylinder(diameter, length);
if (clearLength) {
|
javascript
|
{
"resource": ""
}
|
|
q3821
|
_formatErrorsWarnings
|
train
|
function _formatErrorsWarnings(level, list, projectRoot){
return list.map(x => {
let file, line, col, endLine, endCol, message
try{
// resolve the relative path
let fullFilePath = data_get(x, 'module.resource')
file = fullFilePath && projectRoot ? path.relative(projectRoot, fullFilePath) : ''
// file = file.replace(/[\\//]/g, '/')
line = data_get(x, 'error.error.loc.line') || 0
col = data_get(x, 'error.error.loc.column') || 0
// only need first line of message
let fullMessage = (x.message + '').trim()
let crPos = fullMessage.indexOf("\n")
if (crPos >= 0){
message = fullMessage.substring(0, crPos)
} else {
message = fullMessage
}
if (!line){
let linesColsInfo
let m
if (x.name === 'ModuleNotFoundError'
&& (m = fullMessage.match(MODULE_NOT_FOUND_ERR_MSG_PATTERN))){
linesColsInfo = _resolveLineColNumInFile(fullFilePath, m[1])
} else if (fullMessage.indexOf('component lists rendered with v-for should have explicit keys') > 0
&& (m = fullMessage.match(/([a-zA-Z-_]+)\s+(v-for=['"].*?['"])/))){
linesColsInfo = _resolveLineColNumInFile(fullFilePath, m[2], {after: m[1]})
} else if (m = fullMessage.match(/export ['"](\S+?)['"] was not found/)){
|
javascript
|
{
"resource": ""
}
|
q3822
|
_resolveLineColNumInFile
|
train
|
function _resolveLineColNumInFile(file, message, options={}){
if (!message){
return {line: 0, col: 0}
}
let fileContent = fs.readFileSync(file, 'utf8')
let beyondPos = 0
switch (typeof options.after){
case 'string':
beyondPos = fileContent.indexOf(options.after)
break
case 'number':
beyondPos = options.after
break
default:
break
}
let pos = fileContent.indexOf(message, beyondPos >= 0 ? beyondPos : 0)
|
javascript
|
{
"resource": ""
}
|
q3823
|
qpdecode
|
train
|
function qpdecode(callback) {
return function(data) {
var string = callback(data);
return string
.replace(/[\t\x20]$/gm, '')
|
javascript
|
{
"resource": ""
}
|
q3824
|
order
|
train
|
function order(type, name) {
if (type === '' || type === 'M') return name;
if (type === 'm') return type + name;
if (type === 'aug') return name + '#5';
if (type === 'm#5') return 'm' + name + '#5';
if
|
javascript
|
{
"resource": ""
}
|
q3825
|
indicesToItems
|
train
|
function indicesToItems(target, items, indices, r) {
for (var i = 0;
|
javascript
|
{
"resource": ""
}
|
q3826
|
makeGlobal
|
train
|
function makeGlobal(pattern) {
var flags = 'g';
if (pattern.multiline) flags += 'm';
if (pattern.ignoreCase) flags += 'i';
if (pattern.sticky) flags +=
|
javascript
|
{
"resource": ""
}
|
q3827
|
forEach
|
train
|
function forEach(iterable, callback) {
var iterator, k, i, l, s;
if (!iterable)
throw new Error('obliterator/forEach: invalid iterable.');
if (typeof callback !== 'function')
throw new Error('obliterator/forEach: expecting a callback.');
// The target is an array or a string or function arguments
if (
Array.isArray(iterable) ||
(ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable)) ||
typeof iterable === 'string' ||
iterable.toString() === '[object Arguments]'
) {
for (i = 0, l = iterable.length; i < l; i++)
callback(iterable[i], i);
return;
}
// The target has a #.forEach method
if (typeof iterable.forEach === 'function') {
iterable.forEach(callback);
return;
}
// The target is iterable
if (
SYMBOL_SUPPORT &&
|
javascript
|
{
"resource": ""
}
|
q3828
|
initTmpDir
|
train
|
function initTmpDir (dirname, cb) {
var dir = path.join(os.tmpDir(), dirname);
rmrf(dir, function (err)
|
javascript
|
{
"resource": ""
}
|
q3829
|
p
|
train
|
function p() {
// global promise object to wait for all plot options to be completed before writing
this.promises = [];
// global array for options to plot
this.optArray = [];
// simple plot
this.plot = function(seriesArr, title, yLabel, xLabel) {
// console.log("plotting")
var defer = q.defer();
this.promises.push(defer.promise);
title = title || false;
yLabel = yLabel || false;
xLabel = xLabel || false;
var opt = _.cloneDeep(tmpOpt),
set = _.set.bind(null, opt);
set('series', seriesArr);
set('title.text', title);
set('yAxis.title.text', yLabel);
set('xAxis.title.text', xLabel);
// setTimeout(function() {}, 2000);
this.optArray.push(opt);
defer.resolve();
return opt;
};
// advance plot = specify your own highcharts options
this.advPlot = function(opt) {
var defer = q.defer();
this.promises.push(defer.promise);
this.optArray.push(opt);
defer.resolve();
return opt;
};
// write highchart options to json for rendering
// if autosave is true, charts will save on view
this.write = function(autosave) {
var defer = q.defer();
for (var i = 0; i < this.optArray.length; i++) {
_.set(this.optArray[i], 'chart.renderTo', 'hchart' + i);
|
javascript
|
{
"resource": ""
}
|
q3830
|
localExport
|
train
|
function localExport(opt) {
var ind = _.reGet(/\d/)(opt.chart.renderTo);
_.assign(opt, {
'exporting': {
'buttons': {
'contextButton': {
'y': -10,
'menuItems': [{
'text': 'Save as PNG',
onclick: function() {
this.createCanvas(opt.title, 'png', ind);
},
'separator': false
}, {
|
javascript
|
{
"resource": ""
}
|
q3831
|
docme
|
train
|
function docme(readme, args, jsdocargs, cb) {
args = args || {};
jsdocargs = jsdocargs || [];
log.level = args.loglevel || 'info';
var projectRoot = args.projectRoot || process.cwd()
, projectName = path.basename(projectRoot)
resolveReadme(readme, function (err, fullPath) {
|
javascript
|
{
"resource": ""
}
|
q3832
|
train
|
function(schema) {
if (!schema) {
throw new Error('Schema is empty');
|
javascript
|
{
"resource": ""
}
|
|
q3833
|
unrar
|
train
|
function unrar(arrayBuffer) {
RarEventMgr.emitStart();
var bstream = new BitStream(arrayBuffer, false /* rtl */ );
var header = new RarVolumeHeader(bstream);
if (header.crc == 0x6152 &&
header.headType == 0x72 &&
header.flags.value == 0x1A21 &&
header.headSize == 7) {
RarEventMgr.emitInfo("Found RAR signature");
var mhead = new RarVolumeHeader(bstream);
if (mhead.headType != RarUtils.VOLUME_TYPES.MAIN_HEAD) {
RarEventMgr.emitError("Error! RAR did not include a MAIN_HEAD header");
} else {
var localFiles = [],
localFile = null;
do {
try {
localFile = new RarLocalFile(bstream);
RarEventMgr.emitInfo("RAR localFile isValid=" + localFile.isValid + ", volume packSize=" + localFile.header.packSize);
if (localFile && localFile.isValid && localFile.header.packSize > 0) {
RarUtils.PROGRESS.totalUncompressedBytesInArchive += localFile.header.unpackedSize;
localFiles.push(localFile);
} else if (localFile.header.packSize == 0 && localFile.header.unpackedSize == 0) {
localFile.isValid = true;
}
} catch (err) {
break;
}
RarEventMgr.emitInfo("bstream" + bstream.bytePtr + "/" + bstream.bytes.length);
} while (localFile.isValid);
RarUtils.PROGRESS.totalFilesInArchive = localFiles.length;
// now we have all console.information but things are unpacked
// TODO: unpack
localFiles = localFiles.sort(function(a, b) {
var aname = a.filename;
var bname = b.filename;
return aname > bname ? 1 : -1;
|
javascript
|
{
"resource": ""
}
|
q3834
|
BitStream
|
train
|
function BitStream(ab, rtl, opt_offset, opt_length) {
// if (!ab || !ab.toString || ab.toString() !== "[object ArrayBuffer]") {
// throw "Error! BitArray constructed with an invalid ArrayBuffer object";
// }
var offset = opt_offset || 0;
var length = opt_length || ab.byteLength;
this.bytes = new Uint8Array(ab, offset, length);
this.bytePtr
|
javascript
|
{
"resource": ""
}
|
q3835
|
mapRoutes
|
train
|
function mapRoutes(msg, done) {
var seneca = this
var adapter = msg.adapter || locals.adapter
var context = msg.context || locals.context
var options = msg.options || locals.options
var routes = Mapper(msg.routes)
var auth = msg.auth || locals.auth
//
|
javascript
|
{
"resource": ""
}
|
q3836
|
setServer
|
train
|
function setServer(msg, done) {
var seneca = this
var context = msg.context || locals.context
var adapter = msg.adapter || locals.adapter
var options = msg.options || locals.options
var auth = msg.auth || locals.auth
var routes = msg.routes
// If the adapter is a string, we look up the
// adapters collection in opts.adapters.
if (!_.isFunction(adapter)) {
|
javascript
|
{
"resource": ""
}
|
q3837
|
cmd
|
train
|
function cmd(handlers)
{
this.fieldindex = 0;
this.state = "start";
this.stmt = ""
this.params = []
// mixin all handlers
for (var h in handlers)
{
this[h] = handlers[h];
}
|
javascript
|
{
"resource": ""
}
|
q3838
|
updateJXcoreExtensionImport
|
train
|
function updateJXcoreExtensionImport(context) {
var cordovaUtil =
context.requireCordovaModule('cordova-lib/src/cordova/util');
var ConfigParser = context.requireCordovaModule('cordova-lib').configparser;
var projectRoot = cordovaUtil.isCordova();
var xml = cordovaUtil.projectConfig(projectRoot);
var cfg = new ConfigParser(xml);
var Q = context.requireCordovaModule('q');
var deferred = new Q.defer();
var jxcoreExtensionPath = path.join(
context.opts.plugin.dir, 'src', 'ios', 'JXcoreExtension.m');
try {
console.log('Updating JXcoreExtension.m');
|
javascript
|
{
"resource": ""
}
|
q3839
|
train
|
function (methodName, callback) {
Mobile(methodName).registerToNative(callback);
Mobile('didRegisterToNative').callNative(methodName, function () {
|
javascript
|
{
"resource": ""
}
|
|
q3840
|
compareBufferArrays
|
train
|
function compareBufferArrays(buffArray1, buffArray2) {
assert(Array.isArray(buffArray1), 'We only accept arrays.');
assert(Array.isArray(buffArray2), 'We only accept arrays.');
if (buffArray1.length !== buffArray2.length) {
return false;
}
for (var i = 0; i < buffArray1.length; ++i) {
var buff1 = buffArray1[i];
assert(Buffer.isBuffer(buff1), 'Only buffers allowed in 1');
|
javascript
|
{
"resource": ""
}
|
q3841
|
closeOldestServer
|
train
|
function closeOldestServer() {
var oldest = null;
Object.keys(self._peerServers).forEach(function (k) {
if (oldest == null) {
oldest = k;
}
else {
if (self._peerServers[k].lastActive <
|
javascript
|
{
"resource": ""
}
|
q3842
|
httpRequestPromise
|
train
|
function httpRequestPromise(method, urlObject) {
if (method !== 'GET' && method !== 'HEAD') {
return Promise.reject(new Error('We only support GET or HEAD requests'));
}
return new Promise(function (resolve, reject) {
var httpsRequestOptions = {
host: urlObject.host,
method: method,
|
javascript
|
{
"resource": ""
}
|
q3843
|
getReleaseConfig
|
train
|
function getReleaseConfig() {
var configFileName = path.join(__dirname, '..', 'package.json');
return fs.readFileAsync(configFileName, 'utf-8')
.then(function (data) {
var conf;
try {
conf = JSON.parse(data);
if (conf && conf.thaliInstall) {
|
javascript
|
{
"resource": ""
}
|
q3844
|
doGitHubEtagsMatch
|
train
|
function doGitHubEtagsMatch(projectName, depotName, branchName,
directoryToInstallIn) {
return getEtagFromEtagFile(depotName, branchName, directoryToInstallIn)
.then(function (etagFromFile) {
if (!etagFromFile) {
return false;
}
return httpRequestPromise('HEAD',
|
javascript
|
{
"resource": ""
}
|
q3845
|
copyDevelopmentThaliCordovaPluginToProject
|
train
|
function copyDevelopmentThaliCordovaPluginToProject(appRootDirectory,
thaliDontCheckIn,
depotName,
branchName) {
var targetDirectory = createUnzippedDirectoryPath(depotName, branchName,
thaliDontCheckIn);
var sourceDirectory = path.join(
appRootDirectory, '..', 'Thali_CordovaPlugin');
return new Promise(function (resolve, reject) {
fs.remove(targetDirectory, function (err) {
if (err) {
reject(new Error('copyDevelopmentThaliCordovaPluginToProject remove ' +
'failed with ' + err));
|
javascript
|
{
"resource": ""
}
|
q3846
|
checkVersion
|
train
|
function checkVersion(objectName, versionNumber) {
const desiredVersion = versionNumber ? versionNumber : versions[objectName];
const commandAndResult = commandsAndResults[objectName];
if (!commandAndResult) {
return Promise.reject(
new Error('Unrecognized objectName in commandsAndResults'));
}
if (!desiredVersion) {
return Promise.reject(new Error('Unrecognized objectName in versions'));
}
if (commandAndResult.platform &&
!commandAndResult.platform.includes(os.platform()))
{
return Promise.reject(new Error('Requested object is not supported on ' +
'this platform'));
}
if (typeof commandAndResult.versionCheck === 'function') {
return promiseTry(commandAndResult.versionCheck)
.catch(() =>
Promise.reject(new Error('Version Check failed on ' + objectName)))
.then((versionCheckResult) =>
|
javascript
|
{
"resource": ""
}
|
q3847
|
findFirstFile
|
train
|
function findFirstFile (name, rootDir) {
return new Promise(function (resolve, reject) {
var resultPath;
function end() {
if (resultPath) {
resolve(resultPath);
} else {
reject(new Error(
format('file is not found, name: \'%s\'', name)
));
}
}
var finder = findit(rootDir)
.on('file', function (path) {
// We can receive here 'path': 'a/b/my-file', 'a/b/bad-my-file',
// 'my-file', 'bad-my-file'.
// Both 'a/b/my-file' and 'my-file' should be valid.
if (path === name || endsWith(path, '/' + name)) {
resultPath = path;
finder.stop();
}
|
javascript
|
{
"resource": ""
}
|
q3848
|
ConnectionTable
|
train
|
function ConnectionTable(thaliReplicationManager) {
EventEmitter.call(this);
var self = this;
this.thaliReplicationManager = thaliReplicationManager;
this.connectionTable = {};
this.connectionSuccessListener = function (successObject) {
|
javascript
|
{
"resource": ""
}
|
q3849
|
start
|
train
|
function start (router, pskIdToSecret, networkType) {
if (thaliMobileStates.started === true) {
return Promise.reject(new Error('Call Stop!'));
}
thaliMobileStates.started = true;
thaliMobileStates.networkType =
networkType || global.NETWORK_TYPE || thaliMobileStates.networkType;
return getWifiOrNativeMethodByNetworkType('start',
thaliMobileStates.networkType)(router, pskIdToSecret)
|
javascript
|
{
"resource": ""
}
|
q3850
|
train
|
function (appRoot) {
var filePath = path.join(appRoot,
'platforms/android/src/io/jxcore/node/JXcoreExtension.java');
var content = fs.readFileSync(filePath, 'utf-8');
content = content.replace('lifeCycleMonitor.start();',
'lifeCycleMonitor.start();\n\t\tRegisterExecuteUT.Register();');
content =
|
javascript
|
{
"resource": ""
}
|
|
q3851
|
HKDF
|
train
|
function HKDF(hashAlg, salt, ikm) {
if (!(this instanceof HKDF)) { return new HKDF(hashAlg, salt, ikm); }
this.hashAlg = hashAlg;
// create the hash alg to see if it exists and get its length
var hash = crypto.createHash(this.hashAlg);
this.hashLength = hash.digest().length;
this.salt = salt ||
|
javascript
|
{
"resource": ""
}
|
q3852
|
createPublicKeyHash
|
train
|
function createPublicKeyHash (ecdhPublicKey) {
return crypto.createHash(module.exports.SHA256)
|
javascript
|
{
"resource": ""
}
|
q3853
|
generatePreambleAndBeacons
|
train
|
function generatePreambleAndBeacons (publicKeysToNotify,
ecdhForLocalDevice,
millisecondsUntilExpiration) {
if (publicKeysToNotify == null) {
throw new Error('publicKeysToNotify cannot be null');
}
if (ecdhForLocalDevice == null) {
throw new Error('ecdhForLocalDevice cannot be null');
}
if (millisecondsUntilExpiration <= 0 ||
millisecondsUntilExpiration > module.exports.ONE_DAY) {
throw new Error('millisecondsUntilExpiration must be > 0 & < ' +
module.exports.ONE_DAY);
}
if (publicKeysToNotify.length === 0) { return null; }
var beacons = [];
var ke = crypto.createECDH(thaliConfig.BEACON_CURVE);
// Generate preamble
var pubKe = ke.generateKeys();
// We fuzz the expiration by adding on a random number that fits in
// an unsigned 8 bit integer.
var expiration = Date.now() + millisecondsUntilExpiration +
crypto.randomBytes(1).readUInt8(0);
var expirationLong = Long.fromNumber(expiration);
var expirationBuffer = new Buffer(module.exports.LONG_SIZE);
expirationBuffer.writeInt32BE(expirationLong.high, 0);
expirationBuffer.writeInt32BE(expirationLong.low, 4);
beacons.push(Buffer.concat([pubKe, expirationBuffer]));
// UnencryptedKeyId = SHA256(Kx.public().encode()).first(16)
var unencryptedKeyId =
createPublicKeyHash(ecdhForLocalDevice.getPublicKey());
publicKeysToNotify.forEach(function (pubKy) {
// Sxy = ECDH(Kx.private(), PubKy)
var sxy = ecdhForLocalDevice.computeSecret(pubKy);
// HKxy = HKDF(SHA256, Sxy, Expiration, 32)
|
javascript
|
{
"resource": ""
}
|
q3854
|
generatePskSecret
|
train
|
function generatePskSecret(ecdhForLocalDevice, remotePeerPublicKey,
pskIdentityField) {
var sxy = ecdhForLocalDevice.computeSecret(remotePeerPublicKey);
return
|
javascript
|
{
"resource": ""
}
|
q3855
|
generatePskSecrets
|
train
|
function generatePskSecrets(publicKeysToNotify,
ecdhForLocalDevice,
beaconStreamWithPreAmble) {
var preAmbleSizeInBytes = module.exports.PUBLIC_KEY_SIZE +
module.exports.EXPIRATION_SIZE;
var preAmble = beaconStreamWithPreAmble.slice(0, preAmbleSizeInBytes);
var beaconStreamNoPreAmble =
beaconStreamWithPreAmble.slice(preAmbleSizeInBytes);
var beacons = [];
for (var i = 0; i < beaconStreamNoPreAmble.length;
|
javascript
|
{
"resource": ""
}
|
q3856
|
PeerAction
|
train
|
function PeerAction (peerIdentifier, connectionType, actionType, pskIdentity,
pskKey)
{
EventEmitter.call(this);
this._peerIdentifier = peerIdentifier;
|
javascript
|
{
"resource": ""
}
|
q3857
|
BrowserInfo
|
train
|
function BrowserInfo() {
var res = {
name: "",
version: ""
};
var userAgent = self.navigator.userAgent;
var reg;
if (reg = /edge\/([\d\.]+)/i.exec(userAgent)) {
res.name = Browser.Edge;
res.version = reg[1];
}
else if (/msie/i.test(userAgent)) {
res.name = Browser.IE;
res.version = /msie ([\d\.]+)/i.exec(userAgent)[1];
}
else if (/Trident/i.test(userAgent)) {
res.name = Browser.IE;
res.version = /rv:([\d\.]+)/i.exec(userAgent)[1];
}
else if (/chrome/i.test(userAgent)) {
res.name = Browser.Chrome;
res.version = /chrome\/([\d\.]+)/i.exec(userAgent)[1];
}
|
javascript
|
{
"resource": ""
}
|
q3858
|
createUnpackedBundle
|
train
|
function createUnpackedBundle() {
fs.mkdirp(unpackedDir, err => {
if (err && err.code !== 'EEXIST') {
console.log(err);
throw err;
}
let unpackedFile = path.join(__dirname, 'unpacked.js');
let b = browserify(unpackedFile).bundle();
b.on('error', console.error);
let unpackedBundleFile = path.join(unpackedDir, 'unpacked-bundle.js');
const bundleFileStream = fs.createWriteStream(unpackedBundleFile);
bundleFileStream.on('finish', () => {
console.log('Wrote bundled JS into ' + unpackedBundleFile);
|
javascript
|
{
"resource": ""
}
|
q3859
|
train
|
function (query, params, stringifier) {
if (!query || !query.length || !params) {
return query;
}
if (!stringifier) {
stringifier = function (a) {return a.toString()};
}
var parts = [];
var isLiteral = false;
var lastIndex = 0;
var paramsCounter = 0;
for (var i = 0; i < query.length; i++) {
var char = query.charAt(i);
if (char === "'" && query.charAt(i-1) !== '\\') {
//opening or closing quotes in a literal value of the query
isLiteral = !isLiteral;
}
if (!isLiteral &&
|
javascript
|
{
"resource": ""
}
|
|
q3860
|
FrameHeader
|
train
|
function FrameHeader(values) {
if (values) {
if (values instanceof Buffer) {
this.fromBuffer(values);
}
else {
|
javascript
|
{
"resource": ""
}
|
q3861
|
QueueWhile
|
train
|
function QueueWhile(test, delayRetry) {
this.queue = async.queue(function (task, queueCallback) {
async.whilst(
test,
function(cb) {
//Retry in a while
if (delayRetry) {
setTimeout(cb, delayRetry);
|
javascript
|
{
"resource": ""
}
|
q3862
|
DriverError
|
train
|
function DriverError (message, constructor) {
if (constructor) {
Error.captureStackTrace(this, constructor);
this.name = constructor.name;
|
javascript
|
{
"resource": ""
}
|
q3863
|
copyBuffer
|
train
|
function copyBuffer(buf) {
var targetBuffer = new
|
javascript
|
{
"resource": ""
}
|
q3864
|
totalLength
|
train
|
function totalLength (arr) {
if (!arr) {
return 0;
}
var total = 0;
arr.forEach(function (item)
|
javascript
|
{
"resource": ""
}
|
q3865
|
Client
|
train
|
function Client(options) {
events.EventEmitter.call(this);
//Unlimited amount of listeners for internal event queues by default
this.setMaxListeners(0);
this.options =
|
javascript
|
{
"resource": ""
}
|
q3866
|
BatchWriter
|
train
|
function BatchWriter(queries, consistency, options) {
this.queries = queries;
options = utils.extend({atomic: true}, options);
this.type = options.atomic ? 0 : 1;
this.type = options.counter ? 2 : this.type;
this.consistency = consistency;
|
javascript
|
{
"resource": ""
}
|
q3867
|
train
|
function(source) {
var src = (source ? source.src : undefined);
if (this.selectedSrc !== src) {
|
javascript
|
{
"resource": ""
}
|
|
q3868
|
cloneSvg
|
train
|
function cloneSvg(src, attrs, styles) {
var clonedSvg = src.cloneNode(true);
domWalk(src, clonedSvg, function (src, tgt) {
if (tgt.style) {
(0, _computedStyles2['default'])(src, tgt.style, styles);
}
}, function (src, tgt) {
|
javascript
|
{
"resource": ""
}
|
q3869
|
cleanAttrs
|
train
|
function cleanAttrs (el, attrs, styles) { // attrs === false - remove all, attrs === true - allow all
if (attrs === true) { return; }
Array.prototype.slice.call(el.attributes)
.forEach(function (attr) {
// remove if it is not style nor on attrs whitelist
// keeping attributes that are also styles because attributes override
if (attr.specified) {
|
javascript
|
{
"resource": ""
}
|
q3870
|
setFocusedElement
|
train
|
function setFocusedElement(cstOption) {
if (focusedElement) {
focusedElement.classList.remove(builderParams.hasFocusClass);
}
if (typeof cstOption !== 'undefined') {
focusedElement = cstOption;
focusedElement.classList.add(builderParams.hasFocusClass);
// Offset update: checks if the focused element is in the visible part
|
javascript
|
{
"resource": ""
}
|
q3871
|
validateTableDefinition
|
train
|
function validateTableDefinition(tableDefinition) {
// Do basic table name validation and leave the rest to the store
Validate.notNull(tableDefinition, 'tableDefinition');
Validate.isObject(tableDefinition, 'tableDefinition');
Validate.isString(tableDefinition.name, 'tableDefinition.name');
Validate.notNullOrEmpty(tableDefinition.name, 'tableDefinition.name');
// Validate the specified column types and check for duplicate columns
|
javascript
|
{
"resource": ""
}
|
q3872
|
addTableDefinition
|
train
|
function addTableDefinition(tableDefinitions, tableDefinition) {
Validate.isObject(tableDefinitions);
Validate.notNull(tableDefinitions);
|
javascript
|
{
"resource": ""
}
|
q3873
|
getTableDefinition
|
train
|
function getTableDefinition(tableDefinitions, tableName) {
Validate.isObject(tableDefinitions);
Validate.notNull(tableDefinitions);
Validate.isString(tableName);
|
javascript
|
{
"resource": ""
}
|
q3874
|
getColumnType
|
train
|
function getColumnType(columnDefinitions, columnName) {
Validate.isObject(columnDefinitions);
Validate.notNull(columnDefinitions);
Validate.isString(columnName);
Validate.notNullOrEmpty(columnName);
for (var column in columnDefinitions) {
|
javascript
|
{
"resource": ""
}
|
q3875
|
getColumnName
|
train
|
function getColumnName(columnDefinitions, property) {
Validate.isObject(columnDefinitions);
Validate.notNull(columnDefinitions);
Validate.isString(property);
Validate.notNullOrEmpty(property);
for (var column in columnDefinitions) {
|
javascript
|
{
"resource": ""
}
|
q3876
|
getId
|
train
|
function getId(record) {
Validate.isObject(record);
Validate.notNull(record);
for (var property
|
javascript
|
{
"resource": ""
}
|
q3877
|
isId
|
train
|
function isId(property) {
Validate.isString(property);
Validate.notNullOrEmpty(property);
|
javascript
|
{
"resource": ""
}
|
q3878
|
upsertWithLogging
|
train
|
function upsertWithLogging(tableName, instance, action, shouldOverwrite) {
Validate.isString(tableName, 'tableName');
Validate.notNullOrEmpty(tableName, 'tableName');
Validate.notNull(instance, 'instance');
Validate.isValidId(instance.id, 'instance.id');
if (!store) {
throw new Error('MobileServiceSyncContext not initialized');
}
return store.lookup(tableName, instance.id, true /* suppressRecordNotFoundError */).then(function(existingRecord) {
if (existingRecord && !shouldOverwrite) {
throw new Error('Record with id ' + existingRecord.id + ' already exists in the table ' + tableName);
}
|
javascript
|
{
"resource": ""
}
|
q3879
|
getSqliteType
|
train
|
function getSqliteType (columnType) {
var sqliteType;
switch (columnType) {
case ColumnType.Object:
case ColumnType.Array:
case ColumnType.String:
case ColumnType.Text:
sqliteType = "TEXT";
break;
case ColumnType.Integer:
case ColumnType.Int:
case ColumnType.Boolean:
case ColumnType.Bool:
case ColumnType.Date:
sqliteType = "INTEGER";
break;
|
javascript
|
{
"resource": ""
}
|
q3880
|
serialize
|
train
|
function serialize (value, columnDefinitions) {
var serializedValue = {};
try {
Validate.notNull(columnDefinitions, 'columnDefinitions');
Validate.isObject(columnDefinitions);
Validate.notNull(value);
Validate.isObject(value);
for (var property in value) {
var columnType = storeHelper.getColumnType(columnDefinitions, property);
// Skip properties that don't match any column in the table
|
javascript
|
{
"resource": ""
}
|
q3881
|
deserialize
|
train
|
function deserialize (value, columnDefinitions) {
var deserializedValue = {};
try {
Validate.notNull(columnDefinitions, 'columnDefinitions');
Validate.isObject(columnDefinitions);
Validate.notNull(value);
Validate.isObject(value);
for (var property in value) {
var columnName = storeHelper.getColumnName(columnDefinitions, property); // this helps us deserialize with proper case for the property name
|
javascript
|
{
"resource": ""
}
|
q3882
|
serializeMember
|
train
|
function serializeMember(value, columnType) {
// Start by checking if the specified column type is valid
if (!isColumnTypeValid(columnType)) {
throw new Error('Column type ' + columnType + ' is not supported');
}
// Now check if the specified value can be stored in a column of type columnType
if (!isJSValueCompatibleWithColumnType(value, columnType)) {
throw new Error('Converting value ' + JSON.stringify(value) + ' of type ' + typeof value + ' to type ' + columnType + ' is not supported.');
}
// If we are here, it means we are good to proceed with serialization
var sqliteType = getSqliteType(columnType),
serializedValue;
switch (sqliteType) {
|
javascript
|
{
"resource": ""
}
|
q3883
|
deserializeMember
|
train
|
function deserializeMember(value, columnType) {
// Handle this special case first.
// Simply return 'value' if a corresponding columnType is not defined.
if (!columnType) {
return value;
}
// Start by checking if the specified column type is valid.
if (!isColumnTypeValid(columnType)) {
throw new Error('Column type ' + columnType + ' is not supported');
}
// Now check if the specified value can be stored in a column of type columnType.
if (!isSqliteValueCompatibleWithColumnType(value, columnType)) {
throw new Error('Converting value ' + JSON.stringify(value) + ' of type ' + typeof value +
' to type ' + columnType + ' is not supported.');
}
// If we are here, it means we are good to proceed with deserialization
var deserializedValue, error;
switch (columnType) {
case ColumnType.Object:
deserializedValue = typeConverter.convertToObject(value);
break;
case ColumnType.Array:
deserializedValue = typeConverter.convertToArray(value);
break;
case ColumnType.String:
case ColumnType.Text:
deserializedValue = typeConverter.convertToText(value);
break;
|
javascript
|
{
"resource": ""
}
|
q3884
|
serializeValue
|
train
|
function serializeValue(value) {
var type;
if ( _.isNull(value) ) {
type = ColumnType.Object;
} else if ( _.isNumber(value) ) {
type = ColumnType.Real;
} else if ( _.isDate(value) ) {
type = ColumnType.Date;
} else if ( _.isBool(value) ) {
type = ColumnType.Boolean;
} else if ( _.isString(value) ) {
|
javascript
|
{
"resource": ""
}
|
q3885
|
run
|
train
|
function run(task) {
return Platform.async(function(callback) {
// parameter validation
Validate.isFunction(task);
Validate.isFunction(callback);
// Add the task to the queue of pending tasks and
|
javascript
|
{
"resource": ""
}
|
q3886
|
processTask
|
train
|
function processTask() {
setTimeout(function() {
if (isBusy || queue.length === 0) {
return;
}
isBusy = true;
var next = queue.shift(),
result,
error;
Platform.async(function(callback) { // Start a promise chain
callback();
})().then(function() {
return next.task(); // Run the task
}).then(function(res) { // task completed successfully
isBusy = false;
|
javascript
|
{
"resource": ""
}
|
q3887
|
initialize
|
train
|
function initialize () {
return pullTaskRunner.run(function() {
return store.defineTable({
name: pulltimeTableName,
columnDefinitions: {
id: 'string', // column for storing queryId
|
javascript
|
{
"resource": ""
}
|
q3888
|
pull
|
train
|
function pull(query, queryId, settings) {
//TODO: support pullQueryId
//TODO: page size should be configurable
return pullTaskRunner.run(function() {
validateQuery(query, 'query');
Validate.isString(queryId, 'queryId'); // non-null string or null - both are valid
Validate.isObject(settings, 'settings');
settings = settings || {};
if (_.isNull(settings.pageSize)) {
pageSize = defaultPageSize;
} else if (_.isInteger(settings.pageSize) && settings.pageSize > 0) {
pageSize = settings.pageSize;
} else {
throw new Error('Page size must be a positive integer. Page size ' + settings.pageSize + ' is invalid.');
}
// Make a copy of the query as we will be modifying it
tablePullQuery = copyQuery(query);
|
javascript
|
{
"resource": ""
}
|
q3889
|
pullAllPages
|
train
|
function pullAllPages() {
// 1. Pull one page
// 2. Check if Pull is complete
// 3. If it is complete, go to 5. If not, update the query to fetch the next page.
// 4. Go to 1
// 5. DONE
return pullPage().then(function(pulledRecords) {
if (!isPullComplete(pulledRecords)) {
|
javascript
|
{
"resource": ""
}
|
q3890
|
pullPage
|
train
|
function pullPage() {
// Define appropriate parameter to enable fetching of deleted records from the server.
// Assumption is that soft delete is enabled on the server table.
var params = {};
params[tableConstants.includeDeletedFlag] = true;
var pulledRecords;
// azure-query-js does not support datatimeoffset
// As a temporary workaround, convert the query to an odata string and replace datetime' with datetimeoffset'.
var queryString = pagePullQuery.toOData();
var tableName = pagePullQuery.getComponents().table;
queryString = queryString.replace(new RegExp('^/' + tableName), '').replace("datetime'", "datetimeoffset'");
return mobileServiceTable.read(queryString, params).then(function(result) {
pulledRecords = result || [];
var chain
|
javascript
|
{
"resource": ""
}
|
q3891
|
updateQueryForNextPage
|
train
|
function updateQueryForNextPage(pulledRecords) {
return Platform.async(function(callback) {
callback();
})().then(function() {
if (!pulledRecords) {
throw new Error('Something is wrong. pulledRecords cannot be null at this point');
}
var lastRecord = pulledRecords[ pulledRecords.length - 1];
if (!lastRecord) {
throw new Error('Something is wrong. Possibly invalid response from the server. lastRecord cannot be null!');
}
var lastRecordTime = lastRecord[tableConstants.sysProps.updatedAtColumnName];
if (!_.isDate(lastRecordTime)) {
|
javascript
|
{
"resource": ""
}
|
q3892
|
buildQueryFromLastKnownUpdateAt
|
train
|
function buildQueryFromLastKnownUpdateAt(updatedAt) {
lastKnownUpdatedAt = updatedAt;
// Make a copy of the table query and tweak it to fetch the next first page
pagePullQuery = copyQuery(tablePullQuery);
pagePullQuery = pagePullQuery.where(function(lastKnownUpdatedAt) {
// Ideally we would have liked to set this[tableConstants.sysProps.updatedAtColumnName]
// but
|
javascript
|
{
"resource": ""
}
|
q3893
|
onPagePulled
|
train
|
function onPagePulled() {
// For incremental pull, make a note of the lastKnownUpdatedAt in the store
if (pullQueryId) {
return store.upsert(pulltimeTableName, {
id: pullQueryId,
|
javascript
|
{
"resource": ""
}
|
q3894
|
validateQuery
|
train
|
function validateQuery(query) {
Validate.isObject(query);
Validate.notNull(query);
var components = query.getComponents();
for (var i in components.ordering) {
throw new Error('orderBy and orderByDescending clauses are not supported in the pull query');
}
if (components.skip) {
throw new Error('skip is not supported in the pull query');
}
if (components.take) {
throw new Error('take is not supported in the pull query');
|
javascript
|
{
"resource": ""
}
|
q3895
|
copyQuery
|
train
|
function copyQuery(query) {
var components = query.getComponents();
var queryCopy = new Query(components.table);
|
javascript
|
{
"resource": ""
}
|
q3896
|
purge
|
train
|
function purge(query, forcePurge) {
return storeTaskRunner.run(function() {
Validate.isObject(query, 'query');
Validate.notNull(query, 'query');
if (!_.isNull(forcePurge)) {
Validate.isBool(forcePurge, 'forcePurge');
}
// Query for pending operations associated with this table
var operationQuery = new Query(tableConstants.operationTableName)
.where(function(tableName) {
return this.tableName === tableName;
}, query.getComponents().table);
// Query to search for the incremental sync state associated with this table
var incrementalSyncStateQuery = new Query(tableConstants.pulltimeTableName)
.where(function(tableName) {
return this.tableName === tableName;
}, query.getComponents().table);
// 1. In case of force purge, simply remove operation table entries for the table being purged
// Else, ensure no records exists in the operation table for the table being purged.
// 2. Delete pull state for all incremental queries associated with this table
// 3. Delete the records from the table as specified by 'query'
//
// TODO: All store operations performed while purging should be part of a single transaction
// Note: An incremental pull after a purge should fetch purged records again. If we run 3 before 2,
// we might
|
javascript
|
{
"resource": ""
}
|
q3897
|
lockOperation
|
train
|
function lockOperation(id) {
return runner.run(function() {
// Locking a locked operation should have no effect
if (lockedOperationId === id) {
return;
}
if (!lockedOperationId) {
|
javascript
|
{
"resource": ""
}
|
q3898
|
getCondenseAction
|
train
|
function getCondenseAction(pendingOperation, newAction) {
var pendingAction = pendingOperation.action,
condenseAction;
if (pendingAction === 'insert' && newAction === 'update') {
condenseAction = 'nop';
} else if (pendingAction === 'insert' && newAction === 'delete') {
condenseAction = 'remove';
} else if (pendingAction === 'update' && newAction === 'update') {
condenseAction = 'nop';
} else if (pendingAction === 'update' && newAction === 'delete') {
condenseAction = 'modify';
} else if (pendingAction === 'delete' && newAction === 'delete') {
condenseAction = 'nop';
|
javascript
|
{
"resource": ""
}
|
q3899
|
getOperationForInsertingLog
|
train
|
function getOperationForInsertingLog(tableName, action, item) {
return api.getMetadata(tableName, action, item).then(function(metadata) {
return {
tableName: operationTableName,
action: 'upsert',
data: {
id: ++maxId,
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.