_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q19800
|
getIndentation
|
train
|
function getIndentation(str, index) {
let indentStart = index;
let indentEnd = index;
while (indentStart) {
const c = str.charCodeAt(indentStart - 1);
// line break
if (c === 10 || c === 13 || c === 0x2028 || c === 0x2029) {
break;
}
indentStart--;
// not white space
if (c !== 9 && c !== 11 && c !== 12 && c !== 32 && c !== 160) {
indentEnd = indentStart;
}
}
return str.substring(indentStart, indentEnd);
}
|
javascript
|
{
"resource": ""
}
|
q19801
|
guessTitle
|
train
|
function guessTitle(id) {
if (!id) {
return id;
}
return (id.substring(0, 1).toUpperCase() + id.substring(1)).replace(/s(?=cript)/, 'S');
}
|
javascript
|
{
"resource": ""
}
|
q19802
|
highlightLines
|
train
|
function highlightLines(pre, lines, classes) {
lines = typeof lines === 'string' ? lines : pre.getAttribute('data-line');
var ranges = lines.replace(/\s+/g, '').split(',');
var offset = +pre.getAttribute('data-line-offset') || 0;
var parseMethod = isLineHeightRounded() ? parseInt : parseFloat;
var lineHeight = parseMethod(getComputedStyle(pre).lineHeight);
var hasLineNumbers = hasClass(pre, 'line-numbers');
var parentElement = hasLineNumbers ? pre : pre.querySelector('code') || pre;
var mutateActions = /** @type {(() => void)[]} */ ([]);
ranges.forEach(function (currentRange) {
var range = currentRange.split('-');
var start = +range[0];
var end = +range[1] || start;
var line = pre.querySelector('.line-highlight[data-range="' + currentRange + '"]') || document.createElement('div');
mutateActions.push(function () {
line.setAttribute('aria-hidden', 'true');
line.setAttribute('data-range', currentRange);
line.className = (classes || '') + ' line-highlight';
});
// if the line-numbers plugin is enabled, then there is no reason for this plugin to display the line numbers
if (hasLineNumbers && Prism.plugins.lineNumbers) {
var startNode = Prism.plugins.lineNumbers.getLine(pre, start);
var endNode = Prism.plugins.lineNumbers.getLine(pre, end);
if (startNode) {
var top = startNode.offsetTop + 'px';
mutateActions.push(function () {
line.style.top = top;
});
}
if (endNode) {
var height = (endNode.offsetTop - startNode.offsetTop) + endNode.offsetHeight + 'px';
mutateActions.push(function () {
line.style.height = height;
});
}
} else {
mutateActions.push(function () {
line.setAttribute('data-start', start);
if (end > start) {
line.setAttribute('data-end', end);
}
line.style.top = (start - offset - 1) * lineHeight + 'px';
line.textContent = new Array(end - start + 2).join(' \n');
});
}
mutateActions.push(function () {
// allow this to play nicely with the line-numbers plugin
// need to attack to pre as when line-numbers is enabled, the code tag is relatively which screws up the positioning
parentElement.appendChild(line);
});
});
return function () {
mutateActions.forEach(callFunction);
};
}
|
javascript
|
{
"resource": ""
}
|
q19803
|
copyFromAsciiDoc
|
train
|
function copyFromAsciiDoc(keys) {
keys = keys.split(' ');
var o = {};
for (var i = 0, l = keys.length; i < l; i++) {
o[keys[i]] = asciidoc[keys[i]];
}
return o;
}
|
javascript
|
{
"resource": ""
}
|
q19804
|
map
|
train
|
function map(classMap) {
if (typeof classMap === 'function') {
options.classMap = classMap;
} else {
options.classMap = function (className) {
return classMap[className] || className;
};
}
}
|
javascript
|
{
"resource": ""
}
|
q19805
|
train
|
function (token) {
if (!token) {
return '';
}
if (typeof token === 'string') {
return token;
}
if (typeof token.content === 'string') {
return token.content;
}
return token.content.map(stringifyToken).join('');
}
|
javascript
|
{
"resource": ""
}
|
|
q19806
|
train
|
function(obj, func, context) {
if(!_.type(func) == 'function') {
throw Error('The second argument in Utopia.each() must be a function');
};
context = context || obj;
for (var i in obj) {
if(obj.hasOwnProperty && obj.hasOwnProperty(i)) {
var ret = func.call(context, obj[i], i);
if(!!ret || ret === 0 || ret === '') {
return ret;
}
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q19807
|
train
|
function(objects) {
var ret = {};
for(var i=0; i<arguments.length; i++) {
var o = arguments[i];
for(var j in o) {
ret[j] = o[j];
}
}
return ret;
}
|
javascript
|
{
"resource": ""
}
|
|
q19808
|
train
|
function(object, objects) {
for(var i=0; i<arguments.length; i++) {
var o = arguments[i];
for(var j in o) {
if(!(j in object)) {
object[j] = o[j];
}
}
}
return object;
}
|
javascript
|
{
"resource": ""
}
|
|
q19809
|
train
|
function() {
var options;
if(_.type(arguments[0]) === 'string') {
if(_.type(arguments[1]) === 'object') {
// Utopia.element.create('div', { ... });
options = arguments[1];
options.tag = arguments[0];
}
else {
// Utopia.element.create('div', ...);
options = {
tag: arguments[0]
};
// Utopia.element.create('div', [contents]);
if(_.type(arguments[1]) === 'array') {
options.contents = arguments[1];
}
// Utopia.element.create('div', 'Text contents');
else if(_.type(arguments[1]) === 'string' || _.type(arguments[1]) === 'number') {
options.contents = ['' + arguments[1]];
}
}
}
else {
options = arguments[0];
}
var namespace = options.namespace || '', element;
if(namespace) {
element = document.createElementNS(namespace, options.tag);
}
else {
element = document.createElement(options.tag);
}
if (options.className || options.id) {
options.properties = options.properties || {};
options.properties.className = options.className;
options.properties.id = options.id;
}
// Set properties, attributes and contents
_.element.set(element, options);
// Place the element in the DOM (inside, before or after an existing element)
// This could be a selector
if(options.before) {
var before = $(options.before);
if (before && before.parentNode) {
before.parentNode.insertBefore(element, before);
}
}
if (options.after && element.parentNode === null) {
var after = $(options.after);
if (after && after.parentNode) {
after.parentNode.insertBefore(element, after.nextSibling)
}
}
if (options.inside && element.parentNode === null) {
$(options.inside).appendChild(element);
}
return element;
}
|
javascript
|
{
"resource": ""
}
|
|
q19810
|
train
|
function(target, event, callback, traditional) {
if(_.type(target) === 'string' || _.type(target) === 'array') {
var elements = _.type(target) === 'string'? $$(target) : target;
elements.forEach(function(element) {
_.event.bind(element, event, callback, traditional);
});
}
else if(_.type(event) === 'string') {
if(traditional) {
target['on' + event] = callback;
}
else {
target.addEventListener(event, callback, false);
}
}
else if(_.type(event) === 'array') {
for (var i=0; i<event.length; i++) {
_.event.bind(target, event[i], callback, arguments[2]);
}
}
else {
for (var name in event) {
_.event.bind(target, name, event[name], arguments[2]);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q19811
|
train
|
function(target, type, properties) {
if(_.type(target) === 'string' || _.type(target) === 'array') {
var elements = _.type(target) === 'string'? $$(target) : target;
elements.forEach(function(element) {
_.event.fire(element, type, properties);
});
}
else if (document.createEvent) {
var evt = document.createEvent("HTMLEvents");
evt.initEvent(type, true, true );
evt.custom = true;
if(properties) {
_.attach(evt, properties);
}
target.dispatchEvent(evt);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q19812
|
train
|
function(o) {
document.body.setAttribute('data-loading', '');
var xhr = new XMLHttpRequest(),
method = o.method || 'GET',
data = o.data || '';
xhr.open(method, o.url + (method === 'GET' && data? '?' + data : ''), true);
o.headers = o.headers || {};
if(method !== 'GET' && !o.headers['Content-type'] && !o.headers['Content-Type']) {
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
}
for (var header in o.headers) {
xhr.setRequestHeader(header, o.headers[header]);
}
xhr.onreadystatechange = function(){
if(xhr.readyState === 4) {
document.body.removeAttribute('data-loading');
o.callback(xhr);
}
};
xhr.send(method === 'GET'? null : data);
return xhr;
}
|
javascript
|
{
"resource": ""
}
|
|
q19813
|
handleToken
|
train
|
function handleToken(tokens, name) {
var value = tokens[name];
var type = Prism.util.type(value);
switch (type) {
case 'RegExp':
var inside = {};
tokens[name] = {
pattern: value,
inside: inside
};
addInvisibles(inside);
break;
case 'Array':
for (var i = 0, l = value.length; i < l; i++) {
handleToken(value, i);
}
break;
default: // 'Object'
var inside = value.inside || (value.inside = {});
addInvisibles(inside);
break;
}
}
|
javascript
|
{
"resource": ""
}
|
q19814
|
train
|
function(prefix, func, values) {
// Default value for angle
var angle = '180deg';
if (/^(?:-?\d*\.?\d+(?:deg|rad)|to\b|top|right|bottom|left)/.test(values[0])) {
angle = values.shift();
if (angle.indexOf('to ') < 0) {
// Angle uses old keywords
// W3C syntax uses "to" + opposite keywords
if (angle.indexOf('top') >= 0) {
if (angle.indexOf('left') >= 0) {
angle = 'to bottom right';
} else if (angle.indexOf('right') >= 0) {
angle = 'to bottom left';
} else {
angle = 'to bottom';
}
} else if (angle.indexOf('bottom') >= 0) {
if (angle.indexOf('left') >= 0) {
angle = 'to top right';
} else if (angle.indexOf('right') >= 0) {
angle = 'to top left';
} else {
angle = 'to top';
}
} else if (angle.indexOf('left') >= 0) {
angle = 'to right';
} else if (angle.indexOf('right') >= 0) {
angle = 'to left';
} else if (prefix) {
// Angle is shifted by 90deg in prefixed gradients
if (angle.indexOf('deg') >= 0) {
angle = (90 - parseFloat(angle)) + 'deg';
} else if (angle.indexOf('rad') >= 0) {
angle = (Math.PI / 2 - parseFloat(angle)) + 'rad';
}
}
}
}
return func + '(' + angle + ',' + values.join(',') + ')';
}
|
javascript
|
{
"resource": ""
}
|
|
q19815
|
train
|
function(prefix, func, values) {
if (values[0].indexOf('at') < 0) {
// Looks like old syntax
// Default values
var position = 'center';
var shape = 'ellipse';
var size = 'farthest-corner';
if (/\bcenter|top|right|bottom|left\b|^\d+/.test(values[0])) {
// Found a position
// Remove angle value, if any
position = values.shift().replace(/\s*-?\d+(?:rad|deg)\s*/, '');
}
if (/\bcircle|ellipse|closest|farthest|contain|cover\b/.test(values[0])) {
// Found a shape and/or size
var shapeSizeParts = values.shift().split(/\s+/);
if (shapeSizeParts[0] && (shapeSizeParts[0] === 'circle' || shapeSizeParts[0] === 'ellipse')) {
shape = shapeSizeParts.shift();
}
if (shapeSizeParts[0]) {
size = shapeSizeParts.shift();
}
// Old keywords are converted to their synonyms
if (size === 'cover') {
size = 'farthest-corner';
} else if (size === 'contain') {
size = 'clothest-side';
}
}
return func + '(' + shape + ' ' + size + ' at ' + position + ',' + values.join(',') + ')';
}
return func + '(' + values.join(',') + ')';
}
|
javascript
|
{
"resource": ""
}
|
|
q19816
|
docCommentSupport
|
train
|
function docCommentSupport(lang, callback) {
var tokenName = 'doc-comment';
var grammar = Prism.languages[lang];
if (!grammar) {
return;
}
var token = grammar[tokenName];
if (!token) {
// add doc comment: /** */
var definition = {};
definition[tokenName] = {
pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
alias: 'comment'
};
grammar = Prism.languages.insertBefore(lang, 'comment', definition);
token = grammar[tokenName];
}
if (token instanceof RegExp) { // convert regex to object
token = grammar[tokenName] = { pattern: token };
}
if (Array.isArray(token)) {
for (var i = 0, l = token.length; i < l; i++) {
if (token[i] instanceof RegExp) {
token[i] = { pattern: token[i] };
}
callback(token[i]);
}
} else {
callback(token);
}
}
|
javascript
|
{
"resource": ""
}
|
q19817
|
addSupport
|
train
|
function addSupport(languages, docLanguage) {
if (typeof languages === 'string') {
languages = [languages];
}
languages.forEach(function (lang) {
docCommentSupport(lang, function (pattern) {
if (!pattern.inside) {
pattern.inside = {};
}
pattern.inside.rest = docLanguage;
});
});
}
|
javascript
|
{
"resource": ""
}
|
q19818
|
train
|
function (element) {
if (!element) {
return null;
}
return window.getComputedStyle ? getComputedStyle(element) : (element.currentStyle || null);
}
|
javascript
|
{
"resource": ""
}
|
|
q19819
|
train
|
function (element, number) {
if (element.tagName !== 'PRE' || !element.classList.contains(PLUGIN_NAME)) {
return;
}
var lineNumberRows = element.querySelector('.line-numbers-rows');
var lineNumberStart = parseInt(element.getAttribute('data-start'), 10) || 1;
var lineNumberEnd = lineNumberStart + (lineNumberRows.children.length - 1);
if (number < lineNumberStart) {
number = lineNumberStart;
}
if (number > lineNumberEnd) {
number = lineNumberEnd;
}
var lineIndex = number - lineNumberStart;
return lineNumberRows.children[lineIndex];
}
|
javascript
|
{
"resource": ""
}
|
|
q19820
|
forEach
|
train
|
function forEach(data, callback) {
if (data && isFunction(callback)) {
if (Array.isArray(data) || isNumber(data.length) /* array-like */) {
var length = data.length;
var i = void 0;
for (i = 0; i < length; i += 1) {
if (callback.call(data, data[i], i, data) === false) {
break;
}
}
} else if (isObject(data)) {
Object.keys(data).forEach(function (key) {
callback.call(data, data[key], key, data);
});
}
}
return data;
}
|
javascript
|
{
"resource": ""
}
|
q19821
|
setStyle
|
train
|
function setStyle(element, styles) {
var style = element.style;
forEach(styles, function (value, property) {
if (REGEXP_SUFFIX.test(property) && isNumber(value)) {
value += 'px';
}
style[property] = value;
});
}
|
javascript
|
{
"resource": ""
}
|
q19822
|
getData
|
train
|
function getData(element, name) {
if (isObject(element[name])) {
return element[name];
} else if (element.dataset) {
return element.dataset[name];
}
return element.getAttribute('data-' + hyphenate(name));
}
|
javascript
|
{
"resource": ""
}
|
q19823
|
setData
|
train
|
function setData(element, name, data) {
if (isObject(data)) {
element[name] = data;
} else if (element.dataset) {
element.dataset[name] = data;
} else {
element.setAttribute('data-' + hyphenate(name), data);
}
}
|
javascript
|
{
"resource": ""
}
|
q19824
|
removeData
|
train
|
function removeData(element, name) {
if (isObject(element[name])) {
try {
delete element[name];
} catch (e) {
element[name] = undefined;
}
} else if (element.dataset) {
// #128 Safari not allows to delete dataset property
try {
delete element.dataset[name];
} catch (e) {
element.dataset[name] = undefined;
}
} else {
element.removeAttribute('data-' + hyphenate(name));
}
}
|
javascript
|
{
"resource": ""
}
|
q19825
|
isCrossOriginURL
|
train
|
function isCrossOriginURL(url) {
var parts = url.match(REGEXP_ORIGINS);
return parts && (parts[1] !== location.protocol || parts[2] !== location.hostname || parts[3] !== location.port);
}
|
javascript
|
{
"resource": ""
}
|
q19826
|
getAdjustedSizes
|
train
|
function getAdjustedSizes(_ref4) // or 'cover'
{
var aspectRatio = _ref4.aspectRatio,
height = _ref4.height,
width = _ref4.width;
var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'contain';
var isValidNumber = function isValidNumber(value) {
return isFinite(value) && value > 0;
};
if (isValidNumber(width) && isValidNumber(height)) {
var adjustedWidth = height * aspectRatio;
if (type === 'contain' && adjustedWidth > width || type === 'cover' && adjustedWidth < width) {
height = width / aspectRatio;
} else {
width = height * aspectRatio;
}
} else if (isValidNumber(width)) {
height = width / aspectRatio;
} else if (isValidNumber(height)) {
width = height * aspectRatio;
}
return {
width: width,
height: height
};
}
|
javascript
|
{
"resource": ""
}
|
q19827
|
arrayBufferToDataURL
|
train
|
function arrayBufferToDataURL(arrayBuffer, mimeType) {
var uint8 = new Uint8Array(arrayBuffer);
var data = '';
// TypedArray.prototype.forEach is not supported in some browsers.
forEach(uint8, function (value) {
data += fromCharCode(value);
});
return 'data:' + mimeType + ';base64,' + btoa(data);
}
|
javascript
|
{
"resource": ""
}
|
q19828
|
destroy
|
train
|
function destroy() {
var element = this.element;
if (!getData(element, NAMESPACE)) {
return this;
}
if (this.isImg && this.replaced) {
element.src = this.originalUrl;
}
this.uncreate();
removeData(element, NAMESPACE);
return this;
}
|
javascript
|
{
"resource": ""
}
|
q19829
|
zoomTo
|
train
|
function zoomTo(ratio, pivot, _originalEvent) {
var options = this.options,
canvasData = this.canvasData;
var width = canvasData.width,
height = canvasData.height,
naturalWidth = canvasData.naturalWidth,
naturalHeight = canvasData.naturalHeight;
ratio = Number(ratio);
if (ratio >= 0 && this.ready && !this.disabled && options.zoomable) {
var newWidth = naturalWidth * ratio;
var newHeight = naturalHeight * ratio;
if (dispatchEvent(this.element, EVENT_ZOOM, {
originalEvent: _originalEvent,
oldRatio: width / naturalWidth,
ratio: newWidth / naturalWidth
}) === false) {
return this;
}
if (_originalEvent) {
var pointers = this.pointers;
var offset = getOffset(this.cropper);
var center = pointers && Object.keys(pointers).length ? getPointersCenter(pointers) : {
pageX: _originalEvent.pageX,
pageY: _originalEvent.pageY
};
// Zoom from the triggering point of the event
canvasData.left -= (newWidth - width) * ((center.pageX - offset.left - canvasData.left) / width);
canvasData.top -= (newHeight - height) * ((center.pageY - offset.top - canvasData.top) / height);
} else if (isPlainObject(pivot) && isNumber(pivot.x) && isNumber(pivot.y)) {
canvasData.left -= (newWidth - width) * ((pivot.x - canvasData.left) / width);
canvasData.top -= (newHeight - height) * ((pivot.y - canvasData.top) / height);
} else {
// Zoom from the center of the canvas
canvasData.left -= (newWidth - width) / 2;
canvasData.top -= (newHeight - height) / 2;
}
canvasData.width = newWidth;
canvasData.height = newHeight;
this.renderCanvas(true);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q19830
|
setData$$1
|
train
|
function setData$$1(data) {
var options = this.options,
imageData = this.imageData,
canvasData = this.canvasData;
var cropBoxData = {};
if (this.ready && !this.disabled && isPlainObject(data)) {
var transformed = false;
if (options.rotatable) {
if (isNumber(data.rotate) && data.rotate !== imageData.rotate) {
imageData.rotate = data.rotate;
transformed = true;
}
}
if (options.scalable) {
if (isNumber(data.scaleX) && data.scaleX !== imageData.scaleX) {
imageData.scaleX = data.scaleX;
transformed = true;
}
if (isNumber(data.scaleY) && data.scaleY !== imageData.scaleY) {
imageData.scaleY = data.scaleY;
transformed = true;
}
}
if (transformed) {
this.renderCanvas(true, true);
}
var ratio = imageData.width / imageData.naturalWidth;
if (isNumber(data.x)) {
cropBoxData.left = data.x * ratio + canvasData.left;
}
if (isNumber(data.y)) {
cropBoxData.top = data.y * ratio + canvasData.top;
}
if (isNumber(data.width)) {
cropBoxData.width = data.width * ratio;
}
if (isNumber(data.height)) {
cropBoxData.height = data.height * ratio;
}
this.setCropBoxData(cropBoxData);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q19831
|
getCropBoxData
|
train
|
function getCropBoxData() {
var cropBoxData = this.cropBoxData;
var data = void 0;
if (this.ready && this.cropped) {
data = {
left: cropBoxData.left,
top: cropBoxData.top,
width: cropBoxData.width,
height: cropBoxData.height
};
}
return data || {};
}
|
javascript
|
{
"resource": ""
}
|
q19832
|
setCropBoxData
|
train
|
function setCropBoxData(data) {
var cropBoxData = this.cropBoxData;
var aspectRatio = this.options.aspectRatio;
var widthChanged = void 0;
var heightChanged = void 0;
if (this.ready && this.cropped && !this.disabled && isPlainObject(data)) {
if (isNumber(data.left)) {
cropBoxData.left = data.left;
}
if (isNumber(data.top)) {
cropBoxData.top = data.top;
}
if (isNumber(data.width) && data.width !== cropBoxData.width) {
widthChanged = true;
cropBoxData.width = data.width;
}
if (isNumber(data.height) && data.height !== cropBoxData.height) {
heightChanged = true;
cropBoxData.height = data.height;
}
if (aspectRatio) {
if (widthChanged) {
cropBoxData.height = cropBoxData.width / aspectRatio;
} else if (heightChanged) {
cropBoxData.width = cropBoxData.height * aspectRatio;
}
}
this.renderCropBox();
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q19833
|
Cropper
|
train
|
function Cropper(element) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
classCallCheck(this, Cropper);
if (!element || !REGEXP_TAG_NAME.test(element.tagName)) {
throw new Error('The first argument is required and must be an <img> or <canvas> element.');
}
this.element = element;
this.options = assign({}, DEFAULTS, isPlainObject(options) && options);
this.cropped = false;
this.disabled = false;
this.pointers = {};
this.ready = false;
this.reloading = false;
this.replaced = false;
this.sized = false;
this.sizing = false;
this.init();
}
|
javascript
|
{
"resource": ""
}
|
q19834
|
ClientWritableStream
|
train
|
function ClientWritableStream(call) {
Writable.call(this, {objectMode: true});
this.call = call;
var self = this;
this.on('finish', function() {
self.call.halfClose();
});
}
|
javascript
|
{
"resource": ""
}
|
q19835
|
_write
|
train
|
function _write(chunk, encoding, callback) {
/* jshint validthis: true */
var self = this;
if (this.writeFailed) {
/* Once a write fails, just call the callback immediately to let the caller
flush any pending writes. */
setImmediate(callback);
return;
}
var outerCallback = function(err, event) {
if (err) {
/* Assume that the call is complete and that writing failed because a
status was received. In that case, set a flag to discard all future
writes */
self.writeFailed = true;
}
callback();
};
var context = {
encoding: encoding,
callback: outerCallback
};
this.call.sendMessageWithContext(context, chunk);
}
|
javascript
|
{
"resource": ""
}
|
q19836
|
ClientReadableStream
|
train
|
function ClientReadableStream(call) {
Readable.call(this, {objectMode: true});
this.call = call;
this.finished = false;
this.reading = false;
/* Status generated from reading messages from the server. Overrides the
* status from the server if not OK */
this.read_status = null;
/* Status received from the server. */
this.received_status = null;
}
|
javascript
|
{
"resource": ""
}
|
q19837
|
_readsDone
|
train
|
function _readsDone(status) {
/* jshint validthis: true */
if (!status) {
status = {code: constants.status.OK, details: 'OK'};
}
if (status.code !== constants.status.OK) {
this.call.cancelWithStatus(status.code, status.details);
}
this.finished = true;
this.read_status = status;
this._emitStatusIfDone();
}
|
javascript
|
{
"resource": ""
}
|
q19838
|
_emitStatusIfDone
|
train
|
function _emitStatusIfDone() {
/* jshint validthis: true */
var status;
if (this.read_status && this.received_status) {
if (this.read_status.code !== constants.status.OK) {
status = this.read_status;
} else {
status = this.received_status;
}
if (status.code === constants.status.OK) {
this.push(null);
} else {
var error = common.createStatusError(status);
this.emit('error', error);
}
this.emit('status', status);
}
}
|
javascript
|
{
"resource": ""
}
|
q19839
|
_read
|
train
|
function _read(size) {
/* jshint validthis: true */
if (this.finished) {
this.push(null);
} else {
if (!this.reading) {
this.reading = true;
var context = {
stream: this
};
this.call.recvMessageWithContext(context);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q19840
|
ClientDuplexStream
|
train
|
function ClientDuplexStream(call) {
Duplex.call(this, {objectMode: true});
this.call = call;
/* Status generated from reading messages from the server. Overrides the
* status from the server if not OK */
this.read_status = null;
/* Status received from the server. */
this.received_status = null;
var self = this;
this.on('finish', function() {
self.call.halfClose();
});
}
|
javascript
|
{
"resource": ""
}
|
q19841
|
Client
|
train
|
function Client(address, credentials, options) {
var self = this;
if (!options) {
options = {};
}
// Resolve interceptor options and assign interceptors to each method
if (Array.isArray(options.interceptor_providers) && Array.isArray(options.interceptors)) {
throw new client_interceptors.InterceptorConfigurationError(
'Both interceptors and interceptor_providers were passed as options ' +
'to the client constructor. Only one of these is allowed.');
}
self.$interceptors = options.interceptors || [];
self.$interceptor_providers = options.interceptor_providers || [];
if (self.$method_definitions) {
Object.keys(self.$method_definitions).forEach(method_name => {
const method_definition = self.$method_definitions[method_name];
self[method_name].interceptors = client_interceptors
.resolveInterceptorProviders(self.$interceptor_providers, method_definition)
.concat(self.$interceptors);
});
}
this.$callInvocationTransformer = options.callInvocationTransformer;
let channelOverride = options.channelOverride;
let channelFactoryOverride = options.channelFactoryOverride;
// Exclude channel options which have already been consumed
const ignoredKeys = [
'interceptors', 'interceptor_providers', 'channelOverride',
'channelFactoryOverride', 'callInvocationTransformer'
];
var channel_options = Object.getOwnPropertyNames(options)
.reduce((acc, key) => {
if (ignoredKeys.indexOf(key) === -1) {
acc[key] = options[key];
}
return acc;
}, {});
/* Private fields use $ as a prefix instead of _ because it is an invalid
* prefix of a method name */
if (channelOverride) {
this.$channel = options.channelOverride;
} else {
if (channelFactoryOverride) {
this.$channel = channelFactoryOverride(address, credentials, channel_options);
} else {
this.$channel = new grpc.Channel(address, credentials, channel_options);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q19842
|
train
|
function(providers, method_definition) {
if (!Array.isArray(providers)) {
return null;
}
var interceptors = [];
for (var i = 0; i < providers.length; i++) {
var provider = providers[i];
var interceptor = provider(method_definition);
if (interceptor) {
interceptors.push(interceptor);
}
}
return interceptors;
}
|
javascript
|
{
"resource": ""
}
|
|
q19843
|
train
|
function(metadata, current_listener) {
// If there is a next call in the chain, run it. Otherwise do nothing.
if (self.next_call) {
// Wire together any listener provided with the next listener
var listener = _getInterceptingListener(current_listener, next_listener);
self.next_call.start(metadata, listener);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q19844
|
getCall
|
train
|
function getCall(channel, path, options) {
var deadline;
var host;
var parent;
var propagate_flags;
var credentials;
if (options) {
deadline = options.deadline;
host = options.host;
parent = options.parent ? options.parent.call : undefined;
propagate_flags = options.propagate_flags;
credentials = options.credentials;
}
if (deadline === undefined) {
deadline = Infinity;
}
var call = channel.createCall(path, deadline, host,
parent, propagate_flags);
if (credentials) {
call.setCredentials(credentials);
}
return call;
}
|
javascript
|
{
"resource": ""
}
|
q19845
|
_getStreamReadCallback
|
train
|
function _getStreamReadCallback(emitter, call, get_listener, deserialize) {
return function (err, response) {
if (err) {
// Something has gone wrong. Stop reading and wait for status
emitter.finished = true;
emitter._readsDone();
return;
}
var data = response.read;
var deserialized;
try {
deserialized = deserialize(data);
} catch (e) {
emitter._readsDone({
code: constants.status.INTERNAL,
details: 'Failed to parse server response'
});
return;
}
if (data === null) {
emitter._readsDone();
return;
}
var listener = get_listener();
var context = {
call: call,
listener: listener
};
listener.recvMessageWithContext(context, deserialized);
};
}
|
javascript
|
{
"resource": ""
}
|
q19846
|
_areBatchRequirementsMet
|
train
|
function _areBatchRequirementsMet(batch_ops, completed_ops) {
var dependencies = common.flatMap(batch_ops, function(op) {
return OP_DEPENDENCIES[op] || [];
});
for (var i = 0; i < dependencies.length; i++) {
var required_dep = dependencies[i];
if (batch_ops.indexOf(required_dep) === -1 &&
completed_ops.indexOf(required_dep) === -1) {
return false;
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q19847
|
_startBatchIfReady
|
train
|
function _startBatchIfReady(call, batch, batch_state, callback) {
var completed_ops = batch_state.completed_ops;
var deferred_batches = batch_state.deferred_batches;
var batch_ops = Object.keys(batch).map(Number);
if (_areBatchRequirementsMet(batch_ops, completed_ops)) {
// Dependencies are met, start the batch and any deferred batches whose
// dependencies are met as a result.
call.startBatch(batch, callback);
completed_ops = Array.from(new Set(completed_ops.concat(batch_ops)));
deferred_batches = common.flatMap(deferred_batches, function(deferred_batch) {
var deferred_batch_ops = Object.keys(deferred_batch).map(Number);
if (_areBatchRequirementsMet(deferred_batch_ops, completed_ops)) {
call.startBatch(deferred_batch.batch, deferred_batch.callback);
return [];
}
return [deferred_batch];
});
} else {
// Dependencies are not met, defer the batch
deferred_batches = deferred_batches.concat({
batch: batch,
callback: callback
});
}
return {
completed_ops: completed_ops,
deferred_batches: deferred_batches
};
}
|
javascript
|
{
"resource": ""
}
|
q19848
|
_getUnaryInterceptor
|
train
|
function _getUnaryInterceptor(method_definition, channel, emitter, callback) {
var serialize = method_definition.requestSerialize;
var deserialize = method_definition.responseDeserialize;
return function (options) {
var call = getCall(channel, method_definition.path, options);
var first_listener;
var final_requester = {};
var batch_state = {
completed_ops: [],
deferred_batches: []
};
final_requester.start = function (metadata, listener) {
var batch = {
[grpc.opType.SEND_INITIAL_METADATA]:
metadata._getCoreRepresentation(),
};
first_listener = listener;
batch_state = _startBatchIfReady(call, batch, batch_state,
function() {});
};
final_requester.sendMessage = function (message) {
var batch = {
[grpc.opType.SEND_MESSAGE]: serialize(message),
};
batch_state = _startBatchIfReady(call, batch, batch_state,
function() {});
};
final_requester.halfClose = function () {
var batch = {
[grpc.opType.SEND_CLOSE_FROM_CLIENT]: true,
[grpc.opType.RECV_INITIAL_METADATA]: true,
[grpc.opType.RECV_MESSAGE]: true,
[grpc.opType.RECV_STATUS_ON_CLIENT]: true
};
var callback = function (err, response) {
response.status.metadata = Metadata._fromCoreRepresentation(
response.status.metadata);
var status = response.status;
var deserialized;
if (status.code === constants.status.OK) {
if (err) {
// Got a batch error, but OK status. Something went wrong
callback(err);
return;
} else {
try {
deserialized = deserialize(response.read);
} catch (e) {
/* Change status to indicate bad server response. This
* will result in passing an error to the callback */
status = {
code: constants.status.INTERNAL,
details: 'Failed to parse server response'
};
}
}
}
response.metadata =
Metadata._fromCoreRepresentation(response.metadata);
first_listener.onReceiveMetadata(response.metadata);
first_listener.onReceiveMessage(deserialized);
first_listener.onReceiveStatus(status);
};
batch_state = _startBatchIfReady(call, batch, batch_state, callback);
};
final_requester.cancel = function () {
call.cancel();
};
final_requester.cancelWithStatus = function(code, details) {
call.cancelWithStatus(code, details)
};
final_requester.getPeer = function () {
return call.getPeer();
};
return new InterceptingCall(null, final_requester);
};
}
|
javascript
|
{
"resource": ""
}
|
q19849
|
_getServerStreamingInterceptor
|
train
|
function _getServerStreamingInterceptor(method_definition, channel, emitter) {
var deserialize = common.wrapIgnoreNull(
method_definition.responseDeserialize);
var serialize = method_definition.requestSerialize;
return function (options) {
var batch_state = {
completed_ops: [],
deferred_batches: []
};
var call = getCall(channel, method_definition.path, options);
var final_requester = {};
var first_listener;
var get_listener = function() {
return first_listener;
};
final_requester.start = function(metadata, listener) {
first_listener = listener;
metadata = metadata.clone();
var metadata_batch = {
[grpc.opType.SEND_INITIAL_METADATA]: metadata._getCoreRepresentation(),
[grpc.opType.RECV_INITIAL_METADATA]: true
};
var callback = function(err, response) {
if (err) {
// The call has stopped for some reason. A non-OK status will arrive
// in the other batch.
return;
}
first_listener.onReceiveMetadata(
Metadata._fromCoreRepresentation(response.metadata));
};
batch_state = _startBatchIfReady(call, metadata_batch, batch_state,
callback);
var status_batch = {
[grpc.opType.RECV_STATUS_ON_CLIENT]: true
};
call.startBatch(status_batch, function(err, response) {
if (err) {
emitter.emit('error', err);
return;
}
response.status.metadata = Metadata._fromCoreRepresentation(
response.status.metadata);
first_listener.onReceiveStatus(response.status);
});
};
final_requester.sendMessage = function(argument) {
var message = serialize(argument);
if (options) {
message.grpcWriteFlags = options.flags;
}
var send_batch = {
[grpc.opType.SEND_MESSAGE]: message
};
var callback = function(err, response) {
if (err) {
// The call has stopped for some reason. A non-OK status will arrive
// in the other batch.
return;
}
};
batch_state = _startBatchIfReady(call, send_batch, batch_state, callback);
};
final_requester.halfClose = function() {
var batch = {
[grpc.opType.SEND_CLOSE_FROM_CLIENT]: true
};
batch_state = _startBatchIfReady(call, batch, batch_state, function() {});
};
final_requester.recvMessageWithContext = function(context) {
var recv_batch = {
[grpc.opType.RECV_MESSAGE]: true
};
var callback = _getStreamReadCallback(emitter, call,
get_listener, deserialize);
batch_state = _startBatchIfReady(call, recv_batch, batch_state, callback);
};
final_requester.cancel = function() {
call.cancel();
};
final_requester.cancelWithStatus = function(code, details) {
call.cancelWithStatus(code, details)
};
final_requester.getPeer = function() {
return call.getPeer();
};
return new InterceptingCall(null, final_requester);
};
}
|
javascript
|
{
"resource": ""
}
|
q19850
|
_getUnaryListener
|
train
|
function _getUnaryListener(method_definition, emitter, callback) {
var resultMessage;
return {
onReceiveMetadata: function (metadata) {
emitter.emit('metadata', metadata);
},
onReceiveMessage: function (message) {
resultMessage = message;
},
onReceiveStatus: function (status) {
if (status.code !== constants.status.OK) {
var error = common.createStatusError(status);
callback(error);
} else {
callback(null, resultMessage);
}
emitter.emit('status', status);
}
};
}
|
javascript
|
{
"resource": ""
}
|
q19851
|
_getBidiStreamingListener
|
train
|
function _getBidiStreamingListener(method_definition, emitter) {
var deserialize = common.wrapIgnoreNull(
method_definition.responseDeserialize);
return {
onReceiveMetadata: function (metadata) {
emitter.emit('metadata', metadata);
},
onReceiveMessage: function(message, next, context) {
if (emitter.push(message) && message !== null) {
var call = context.call;
var get_listener = function() {
return context.listener;
};
var read_batch = {};
read_batch[grpc.opType.RECV_MESSAGE] = true;
call.startBatch(read_batch, _getStreamReadCallback(emitter, call,
get_listener, deserialize));
} else {
emitter.reading = false;
}
},
onReceiveStatus: function (status) {
emitter._receiveStatus(status);
}
};
}
|
javascript
|
{
"resource": ""
}
|
q19852
|
getLastListener
|
train
|
function getLastListener(method_definition, emitter, callback) {
if (emitter instanceof Function) {
callback = emitter;
callback = function() {};
}
if (!(callback instanceof Function)) {
callback = function() {};
}
if (!((emitter instanceof EventEmitter) &&
(callback instanceof Function))) {
throw new Error('Argument mismatch in getLastListener');
}
var method_type = common.getMethodType(method_definition);
var generator = listenerGenerators[method_type];
return generator(method_definition, emitter, callback);
}
|
javascript
|
{
"resource": ""
}
|
q19853
|
_getLastInterceptor
|
train
|
function _getLastInterceptor(method_definition, channel, responder) {
var callback = (responder instanceof Function) ? responder : function() {};
var emitter = (responder instanceof EventEmitter) ? responder :
new EventEmitter();
var method_type = common.getMethodType(method_definition);
var generator = interceptorGenerators[method_type];
return generator(method_definition, channel, emitter, callback);
}
|
javascript
|
{
"resource": ""
}
|
q19854
|
_buildChain
|
train
|
function _buildChain(interceptors, options) {
var next = function(interceptors) {
if (interceptors.length === 0) {
return function (options) {};
}
var head_interceptor = interceptors[0];
var rest_interceptors = interceptors.slice(1);
return function (options) {
return head_interceptor(options, next(rest_interceptors));
};
};
var chain = next(interceptors)(options);
return new InterceptingCall(chain);
}
|
javascript
|
{
"resource": ""
}
|
q19855
|
handleError
|
train
|
function handleError(call, error) {
var statusMetadata = new Metadata();
var status = {
code: constants.status.UNKNOWN,
details: 'Unknown Error'
};
if (error.hasOwnProperty('message')) {
status.details = error.message;
}
if (error.hasOwnProperty('code') && Number.isInteger(error.code)) {
status.code = error.code;
if (error.hasOwnProperty('details')) {
status.details = error.details;
}
}
if (error.hasOwnProperty('metadata')) {
statusMetadata = error.metadata;
}
status.metadata = statusMetadata._getCoreRepresentation();
var error_batch = {};
if (!call.metadataSent) {
error_batch[grpc.opType.SEND_INITIAL_METADATA] =
(new Metadata())._getCoreRepresentation();
}
error_batch[grpc.opType.SEND_STATUS_FROM_SERVER] = status;
call.startBatch(error_batch, function(){});
}
|
javascript
|
{
"resource": ""
}
|
q19856
|
sendUnaryResponse
|
train
|
function sendUnaryResponse(call, value, serialize, metadata, flags) {
var end_batch = {};
var statusMetadata = new Metadata();
var status = {
code: constants.status.OK,
details: 'OK'
};
if (metadata) {
statusMetadata = metadata;
}
var message;
try {
message = serialize(value);
} catch (e) {
e.code = constants.status.INTERNAL;
handleError(call, e);
return;
}
status.metadata = statusMetadata._getCoreRepresentation();
if (!call.metadataSent) {
end_batch[grpc.opType.SEND_INITIAL_METADATA] =
(new Metadata())._getCoreRepresentation();
call.metadataSent = true;
}
message.grpcWriteFlags = flags;
end_batch[grpc.opType.SEND_MESSAGE] = message;
end_batch[grpc.opType.SEND_STATUS_FROM_SERVER] = status;
call.startBatch(end_batch, function (){});
}
|
javascript
|
{
"resource": ""
}
|
q19857
|
setUpWritable
|
train
|
function setUpWritable(stream, serialize) {
stream.finished = false;
stream.status = {
code : constants.status.OK,
details : 'OK',
metadata : new Metadata()
};
stream.serialize = common.wrapIgnoreNull(serialize);
function sendStatus() {
var batch = {};
if (!stream.call.metadataSent) {
stream.call.metadataSent = true;
batch[grpc.opType.SEND_INITIAL_METADATA] =
(new Metadata())._getCoreRepresentation();
}
if (stream.status.metadata) {
stream.status.metadata = stream.status.metadata._getCoreRepresentation();
}
batch[grpc.opType.SEND_STATUS_FROM_SERVER] = stream.status;
stream.call.startBatch(batch, function(){});
}
stream.on('finish', sendStatus);
/**
* Set the pending status to a given error status. If the error does not have
* code or details properties, the code will be set to grpc.status.UNKNOWN
* and the details will be set to 'Unknown Error'.
* @param {Error} err The error object
*/
function setStatus(err) {
var code = constants.status.UNKNOWN;
var details = 'Unknown Error';
var metadata = new Metadata();
if (err.hasOwnProperty('message')) {
details = err.message;
}
if (err.hasOwnProperty('code')) {
code = err.code;
if (err.hasOwnProperty('details')) {
details = err.details;
}
}
if (err.hasOwnProperty('metadata')) {
metadata = err.metadata;
}
stream.status = {code: code, details: details, metadata: metadata};
}
/**
* Terminate the call. This includes indicating that reads are done, draining
* all pending writes, and sending the given error as a status
* @param {Error} err The error object
* @this GrpcServerStream
*/
function terminateCall(err) {
// Drain readable data
setStatus(err);
stream.end();
}
stream.on('error', terminateCall);
/**
* Override of Writable#end method that allows for sending metadata with a
* success status.
* @param {Metadata=} metadata Metadata to send with the status
*/
stream.end = function(metadata) {
if (metadata) {
stream.status.metadata = metadata;
}
Writable.prototype.end.call(this);
};
}
|
javascript
|
{
"resource": ""
}
|
q19858
|
setStatus
|
train
|
function setStatus(err) {
var code = constants.status.UNKNOWN;
var details = 'Unknown Error';
var metadata = new Metadata();
if (err.hasOwnProperty('message')) {
details = err.message;
}
if (err.hasOwnProperty('code')) {
code = err.code;
if (err.hasOwnProperty('details')) {
details = err.details;
}
}
if (err.hasOwnProperty('metadata')) {
metadata = err.metadata;
}
stream.status = {code: code, details: details, metadata: metadata};
}
|
javascript
|
{
"resource": ""
}
|
q19859
|
setUpReadable
|
train
|
function setUpReadable(stream, deserialize) {
stream.deserialize = common.wrapIgnoreNull(deserialize);
stream.finished = false;
stream.reading = false;
stream.terminate = function() {
stream.finished = true;
stream.on('data', function() {});
};
stream.on('cancelled', function() {
stream.terminate();
});
}
|
javascript
|
{
"resource": ""
}
|
q19860
|
ServerUnaryCall
|
train
|
function ServerUnaryCall(call, metadata) {
EventEmitter.call(this);
this.call = call;
/**
* Indicates if the call has been cancelled
* @member {boolean} grpc~ServerUnaryCall#cancelled
*/
this.cancelled = false;
/**
* The request metadata from the client
* @member {grpc.Metadata} grpc~ServerUnaryCall#metadata
*/
this.metadata = metadata;
/**
* The request message from the client
* @member {*} grpc~ServerUnaryCall#request
*/
this.request = undefined;
}
|
javascript
|
{
"resource": ""
}
|
q19861
|
ServerWritableStream
|
train
|
function ServerWritableStream(call, metadata, serialize) {
Writable.call(this, {objectMode: true});
this.call = call;
this.finished = false;
setUpWritable(this, serialize);
/**
* Indicates if the call has been cancelled
* @member {boolean} grpc~ServerWritableStream#cancelled
*/
this.cancelled = false;
/**
* The request metadata from the client
* @member {grpc.Metadata} grpc~ServerWritableStream#metadata
*/
this.metadata = metadata;
/**
* The request message from the client
* @member {*} grpc~ServerWritableStream#request
*/
this.request = undefined;
}
|
javascript
|
{
"resource": ""
}
|
q19862
|
_write
|
train
|
function _write(chunk, encoding, callback) {
/* jshint validthis: true */
var batch = {};
var self = this;
var message;
try {
message = this.serialize(chunk);
} catch (e) {
e.code = constants.status.INTERNAL;
callback(e);
return;
}
if (!this.call.metadataSent) {
batch[grpc.opType.SEND_INITIAL_METADATA] =
(new Metadata())._getCoreRepresentation();
this.call.metadataSent = true;
}
if (Number.isFinite(encoding)) {
/* Attach the encoding if it is a finite number. This is the closest we
* can get to checking that it is valid flags */
message.grpcWriteFlags = encoding;
}
batch[grpc.opType.SEND_MESSAGE] = message;
this.call.startBatch(batch, function(err, value) {
if (err) {
self.emit('error', err);
return;
}
callback();
});
}
|
javascript
|
{
"resource": ""
}
|
q19863
|
ServerReadableStream
|
train
|
function ServerReadableStream(call, metadata, deserialize) {
Readable.call(this, {objectMode: true});
this.call = call;
setUpReadable(this, deserialize);
/**
* Indicates if the call has been cancelled
* @member {boolean} grpc~ServerReadableStream#cancelled
*/
this.cancelled = false;
/**
* The request metadata from the client
* @member {grpc.Metadata} grpc~ServerReadableStream#metadata
*/
this.metadata = metadata;
}
|
javascript
|
{
"resource": ""
}
|
q19864
|
_read
|
train
|
function _read(size) {
/* jshint validthis: true */
var self = this;
/**
* Callback to be called when a READ event is received. Pushes the data onto
* the read queue and starts reading again if applicable
* @param {grpc.Event} event READ event object
*/
function readCallback(err, event) {
if (err) {
self.terminate();
return;
}
if (self.finished) {
self.push(null);
return;
}
var data = event.read;
var deserialized;
try {
deserialized = self.deserialize(data);
} catch (e) {
e.code = constants.status.INTERNAL;
self.emit('error', e);
return;
}
if (self.push(deserialized) && data !== null) {
var read_batch = {};
read_batch[grpc.opType.RECV_MESSAGE] = true;
self.call.startBatch(read_batch, readCallback);
} else {
self.reading = false;
}
}
if (self.finished) {
self.push(null);
} else {
if (!self.reading) {
self.reading = true;
var batch = {};
batch[grpc.opType.RECV_MESSAGE] = true;
self.call.startBatch(batch, readCallback);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q19865
|
readCallback
|
train
|
function readCallback(err, event) {
if (err) {
self.terminate();
return;
}
if (self.finished) {
self.push(null);
return;
}
var data = event.read;
var deserialized;
try {
deserialized = self.deserialize(data);
} catch (e) {
e.code = constants.status.INTERNAL;
self.emit('error', e);
return;
}
if (self.push(deserialized) && data !== null) {
var read_batch = {};
read_batch[grpc.opType.RECV_MESSAGE] = true;
self.call.startBatch(read_batch, readCallback);
} else {
self.reading = false;
}
}
|
javascript
|
{
"resource": ""
}
|
q19866
|
ServerDuplexStream
|
train
|
function ServerDuplexStream(call, metadata, serialize, deserialize) {
Duplex.call(this, {objectMode: true});
this.call = call;
setUpWritable(this, serialize);
setUpReadable(this, deserialize);
/**
* Indicates if the call has been cancelled
* @member {boolean} grpc~ServerReadableStream#cancelled
*/
this.cancelled = false;
/**
* The request metadata from the client
* @member {grpc.Metadata} grpc~ServerReadableStream#metadata
*/
this.metadata = metadata;
}
|
javascript
|
{
"resource": ""
}
|
q19867
|
sendMetadata
|
train
|
function sendMetadata(responseMetadata) {
/* jshint validthis: true */
var self = this;
if (!this.call.metadataSent) {
this.call.metadataSent = true;
var batch = {};
batch[grpc.opType.SEND_INITIAL_METADATA] =
responseMetadata._getCoreRepresentation();
this.call.startBatch(batch, function(err) {
if (err) {
self.emit('error', err);
return;
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
q19868
|
waitForCancel
|
train
|
function waitForCancel() {
/* jshint validthis: true */
var self = this;
var cancel_batch = {};
cancel_batch[grpc.opType.RECV_CLOSE_ON_SERVER] = true;
self.call.startBatch(cancel_batch, function(err, result) {
if (err) {
self.emit('error', err);
}
if (result.cancelled) {
self.cancelled = true;
self.emit('cancelled');
}
});
}
|
javascript
|
{
"resource": ""
}
|
q19869
|
handleUnary
|
train
|
function handleUnary(call, handler, metadata) {
var emitter = new ServerUnaryCall(call, metadata);
emitter.on('error', function(error) {
handleError(call, error);
});
emitter.waitForCancel();
var batch = {};
batch[grpc.opType.RECV_MESSAGE] = true;
call.startBatch(batch, function(err, result) {
if (err) {
handleError(call, err);
return;
}
try {
emitter.request = handler.deserialize(result.read);
} catch (e) {
e.code = constants.status.INTERNAL;
handleError(call, e);
return;
}
if (emitter.cancelled) {
return;
}
handler.func(emitter, function sendUnaryData(err, value, trailer, flags) {
if (err) {
if (trailer) {
err.metadata = trailer;
}
handleError(call, err);
} else {
sendUnaryResponse(call, value, handler.serialize, trailer, flags);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
q19870
|
handleServerStreaming
|
train
|
function handleServerStreaming(call, handler, metadata) {
var stream = new ServerWritableStream(call, metadata, handler.serialize);
stream.waitForCancel();
var batch = {};
batch[grpc.opType.RECV_MESSAGE] = true;
call.startBatch(batch, function(err, result) {
if (err) {
stream.emit('error', err);
return;
}
try {
stream.request = handler.deserialize(result.read);
} catch (e) {
e.code = constants.status.INTERNAL;
stream.emit('error', e);
return;
}
handler.func(stream);
});
}
|
javascript
|
{
"resource": ""
}
|
q19871
|
handleClientStreaming
|
train
|
function handleClientStreaming(call, handler, metadata) {
var stream = new ServerReadableStream(call, metadata, handler.deserialize);
stream.on('error', function(error) {
handleError(call, error);
});
stream.waitForCancel();
handler.func(stream, function(err, value, trailer, flags) {
stream.terminate();
if (err) {
if (trailer) {
err.metadata = trailer;
}
handleError(call, err);
} else {
sendUnaryResponse(call, value, handler.serialize, trailer, flags);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q19872
|
handleBidiStreaming
|
train
|
function handleBidiStreaming(call, handler, metadata) {
var stream = new ServerDuplexStream(call, metadata, handler.serialize,
handler.deserialize);
stream.waitForCancel();
handler.func(stream);
}
|
javascript
|
{
"resource": ""
}
|
q19873
|
Server
|
train
|
function Server(options) {
this.handlers = {};
var server = new grpc.Server(options);
this._server = server;
this.started = false;
}
|
javascript
|
{
"resource": ""
}
|
q19874
|
checkColorMode
|
train
|
function checkColorMode() {
if (angular.isUndefined(usesRGBA)) {
var testerElement = compile('<div md-colors="{background: \'red\'}" >');
usesRGBA = testerElement[0].style.background.indexOf('rgba') === 0;
}
}
|
javascript
|
{
"resource": ""
}
|
q19875
|
train
|
function(handle) {
if (!isValidID(handle)) return null;
var i, j, instance;
for (i = 0, j = instances.length; i < j; i++) {
instance = instances[i];
if (instance.$$mdHandle === handle) {
return instance;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q19876
|
train
|
function(instance, handle) {
if (!handle) return angular.noop;
instance.$$mdHandle = handle;
instances.push(instance);
resolveWhen();
return deregister;
/**
* Remove registration for an instance
*/
function deregister() {
var index = instances.indexOf(instance);
if (index !== -1) {
instances.splice(index, 1);
}
}
/**
* Resolve any pending promises for this instance
*/
function resolveWhen() {
var dfd = pendings[handle];
if (dfd) {
dfd.forEach(function (promise) {
promise.resolve(instance);
});
delete pendings[handle];
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q19877
|
resolveWhen
|
train
|
function resolveWhen() {
var dfd = pendings[handle];
if (dfd) {
dfd.forEach(function (promise) {
promise.resolve(instance);
});
delete pendings[handle];
}
}
|
javascript
|
{
"resource": ""
}
|
q19878
|
train
|
function(handle) {
if (isValidID(handle)) {
var deferred = $q.defer();
var instance = self.get(handle);
if (instance) {
deferred.resolve(instance);
} else {
if (pendings[handle] === undefined) {
pendings[handle] = [];
}
pendings[handle].push(deferred);
}
return deferred.promise;
}
return $q.reject("Invalid `md-component-id` value.");
}
|
javascript
|
{
"resource": ""
}
|
|
q19879
|
querySearch
|
train
|
function querySearch (query) {
var results = query ? self.vegetables.filter(createFilterFor(query)) : [];
return results;
}
|
javascript
|
{
"resource": ""
}
|
q19880
|
clean
|
train
|
function clean(style) {
return style
.replace(/ng-scope|ng-isolate-scope|md-default-theme/gi,'')
.replace(/\s\s+/g,' ')
.replace(/\s+"/g,'"')
.trim();
}
|
javascript
|
{
"resource": ""
}
|
q19881
|
Codepen
|
train
|
function Codepen($demoAngularScripts, $document, codepenDataAdapter) {
// The following URL used to be HTTP and not HTTPS to allow us to do localhost testing
// It's no longer working, for more info:
// https://blog.codepen.io/2017/03/31/codepen-going-https/
var CODEPEN_API = 'https://codepen.io/pen/define/';
return {
editOnCodepen: editOnCodepen
};
// Creates a codepen from the given demo model by posting to Codepen's API
// using a hidden form. The hidden form is necessary to avoid a CORS issue.
// See http://blog.codepen.io/documentation/api/prefill
function editOnCodepen(demo) {
var externalScripts = $demoAngularScripts.all();
externalScripts.push('https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.22.1/moment.js');
var data = codepenDataAdapter.translate(demo, externalScripts);
var form = buildForm(data);
$document.find('body').append(form);
form[0].submit();
form.remove();
}
// Builds a hidden form with data necessary to create a codepen.
function buildForm(data) {
var form = angular.element(
'<form style="display: none;" method="post" target="_blank" action="' +
CODEPEN_API +
'"></form>'
);
var input = '<input type="hidden" name="data" value="' + escapeJsonQuotes(data) + '" />';
form.append(input);
return form;
}
// Recommended by Codepen to escape quotes.
// See http://blog.codepen.io/documentation/api/prefill
function escapeJsonQuotes(json) {
return JSON.stringify(json)
.replace(/'/g, "&apos;")
.replace(/"/g, "&quot;")
/**
* Codepen was unescaping < (<) and > (>) which caused, on some demos,
* an unclosed elements (like <md-select>).
* Used different unicode lookalike characters so it won't be considered as an element
*/
.replace(/&lt;/g, "˂") // http://graphemica.com/%CB%82
.replace(/&gt;/g, "˃"); // http://graphemica.com/%CB%83
}
}
|
javascript
|
{
"resource": ""
}
|
q19882
|
buildForm
|
train
|
function buildForm(data) {
var form = angular.element(
'<form style="display: none;" method="post" target="_blank" action="' +
CODEPEN_API +
'"></form>'
);
var input = '<input type="hidden" name="data" value="' + escapeJsonQuotes(data) + '" />';
form.append(input);
return form;
}
|
javascript
|
{
"resource": ""
}
|
q19883
|
processHtml
|
train
|
function processHtml(demo) {
var allContent = demo.files.index.contents;
var processors = [
applyAngularAttributesToParentElement,
insertTemplatesAsScriptTags,
htmlEscapeAmpersand
];
processors.forEach(function(processor) {
allContent = processor(allContent, demo);
});
return allContent;
}
|
javascript
|
{
"resource": ""
}
|
q19884
|
processJs
|
train
|
function processJs(jsFiles) {
var mergedJs = mergeFiles(jsFiles).join(' ');
var script = replaceDemoModuleWithCodepenModule(mergedJs);
return script;
}
|
javascript
|
{
"resource": ""
}
|
q19885
|
applyAngularAttributesToParentElement
|
train
|
function applyAngularAttributesToParentElement(html, demo) {
var tmp;
// Grab only the DIV for the demo...
angular.forEach(angular.element(html), function(it,key){
if ((it.nodeName != "SCRIPT") && (it.nodeName != "#text")) {
tmp = angular.element(it);
}
});
tmp.addClass(demo.id);
tmp.attr('ng-app', 'MyApp');
return tmp[0].outerHTML;
}
|
javascript
|
{
"resource": ""
}
|
q19886
|
insertTemplatesAsScriptTags
|
train
|
function insertTemplatesAsScriptTags(indexHtml, demo) {
if (demo.files.html.length) {
var tmp = angular.element(indexHtml);
angular.forEach(demo.files.html, function(template) {
tmp.append("<script type='text/ng-template' id='" +
template.name + "'>" +
template.contents +
"</script>");
});
return tmp[0].outerHTML;
}
return indexHtml;
}
|
javascript
|
{
"resource": ""
}
|
q19887
|
parseColor
|
train
|
function parseColor(color, contrast) {
contrast = contrast || false;
var rgbValues = $mdTheming.PALETTES[color.palette][color.hue];
rgbValues = contrast ? rgbValues.contrast : rgbValues.value;
return $mdUtil.supplant('rgba({0}, {1}, {2}, {3})',
[rgbValues[0], rgbValues[1], rgbValues[2], rgbValues[3] || color.opacity]
);
}
|
javascript
|
{
"resource": ""
}
|
q19888
|
extractColorOptions
|
train
|
function extractColorOptions(expression) {
var parts = expression.split('-');
var hasTheme = angular.isDefined($mdTheming.THEMES[parts[0]]);
var theme = hasTheme ? parts.splice(0, 1)[0] : $mdTheming.defaultTheme();
return {
theme: theme,
palette: extractPalette(parts, theme),
hue: extractHue(parts, theme),
opacity: parts[2] || 1
};
}
|
javascript
|
{
"resource": ""
}
|
q19889
|
extractPalette
|
train
|
function extractPalette(parts, theme) {
// If the next section is one of the palettes we assume it's a two word palette
// Two word palette can be also written in camelCase, forming camelCase to dash-case
var isTwoWord = parts.length > 1 && colorPalettes.indexOf(parts[1]) !== -1;
var palette = parts[0].replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
if (isTwoWord) palette = parts[0] + '-' + parts.splice(1, 1);
if (colorPalettes.indexOf(palette) === -1) {
// If the palette is not in the palette list it's one of primary/accent/warn/background
var scheme = $mdTheming.THEMES[theme].colors[palette];
if (!scheme) {
throw new Error($mdUtil.supplant(
'mdColors: couldn\'t find \'{palette}\' in the palettes.',
{palette: palette}));
}
palette = scheme.name;
}
return palette;
}
|
javascript
|
{
"resource": ""
}
|
q19890
|
compileTemplate
|
train
|
function compileTemplate () {
var template = $attrs.$mdTabsTemplate,
element = angular.element($element[0].querySelector('md-tab-data'));
element.html(template);
$compile(element.contents())(ctrl.parent);
delete $attrs.$mdTabsTemplate;
}
|
javascript
|
{
"resource": ""
}
|
q19891
|
defineOneWayBinding
|
train
|
function defineOneWayBinding (key, handler) {
var attr = $attrs.$normalize('md-' + key);
if (handler) defineProperty(key, handler);
$attrs.$observe(attr, function (newValue) { ctrl[ key ] = newValue; });
}
|
javascript
|
{
"resource": ""
}
|
q19892
|
defineBooleanAttribute
|
train
|
function defineBooleanAttribute (key, handler) {
var attr = $attrs.$normalize('md-' + key);
if (handler) defineProperty(key, handler);
if ($attrs.hasOwnProperty(attr)) updateValue($attrs[attr]);
$attrs.$observe(attr, updateValue);
function updateValue (newValue) {
ctrl[ key ] = newValue !== 'false';
}
}
|
javascript
|
{
"resource": ""
}
|
q19893
|
handleFocusIndexChange
|
train
|
function handleFocusIndexChange (newIndex, oldIndex) {
if (newIndex === oldIndex) return;
if (!getElements().tabs[ newIndex ]) return;
adjustOffset();
redirectFocus();
}
|
javascript
|
{
"resource": ""
}
|
q19894
|
handleResizeWhenVisible
|
train
|
function handleResizeWhenVisible () {
// if there is already a watcher waiting for resize, do nothing
if (handleResizeWhenVisible.watcher) return;
// otherwise, we will abuse the $watch function to check for visible
handleResizeWhenVisible.watcher = $scope.$watch(function () {
// since we are checking for DOM size, we use $mdUtil.nextTick() to wait for after the DOM updates
$mdUtil.nextTick(function () {
// if the watcher has already run (ie. multiple digests in one cycle), do nothing
if (!handleResizeWhenVisible.watcher) return;
if ($element.prop('offsetParent')) {
handleResizeWhenVisible.watcher();
handleResizeWhenVisible.watcher = null;
handleWindowResize();
}
}, false);
});
}
|
javascript
|
{
"resource": ""
}
|
q19895
|
select
|
train
|
function select (index, canSkipClick) {
if (!locked) ctrl.focusIndex = ctrl.selectedIndex = index;
// skip the click event if noSelectClick is enabled
if (canSkipClick && ctrl.noSelectClick) return;
// nextTick is required to prevent errors in user-defined click events
$mdUtil.nextTick(function () {
ctrl.tabs[ index ].element.triggerHandler('click');
}, false);
}
|
javascript
|
{
"resource": ""
}
|
q19896
|
scroll
|
train
|
function scroll (event) {
if (!ctrl.shouldPaginate) return;
event.preventDefault();
if (event.deltaY) {
ctrl.offsetLeft = fixOffset(ctrl.offsetLeft + event.deltaY);
} else if (event.deltaX) {
ctrl.offsetLeft = fixOffset(ctrl.offsetLeft + event.deltaX);
}
}
|
javascript
|
{
"resource": ""
}
|
q19897
|
nextPage
|
train
|
function nextPage () {
if (!ctrl.canPageForward()) { return; }
var newOffset = MdTabsPaginationService.increasePageOffset(getElements(), ctrl.offsetLeft);
ctrl.offsetLeft = fixOffset(newOffset);
}
|
javascript
|
{
"resource": ""
}
|
q19898
|
previousPage
|
train
|
function previousPage () {
if (!ctrl.canPageBack()) { return; }
var newOffset = MdTabsPaginationService.decreasePageOffset(getElements(), ctrl.offsetLeft);
// Set the new offset
ctrl.offsetLeft = fixOffset(newOffset);
}
|
javascript
|
{
"resource": ""
}
|
q19899
|
handleWindowResize
|
train
|
function handleWindowResize () {
ctrl.lastSelectedIndex = ctrl.selectedIndex;
ctrl.offsetLeft = fixOffset(ctrl.offsetLeft);
$mdUtil.nextTick(function () {
ctrl.updateInkBarStyles();
updatePagination();
});
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.