_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q4600
|
_transform
|
train
|
function _transform( xslStr, xmlDoc, xsltParams ) {
const params = xsltParams || {};
return new Promise( ( resolve, reject ) => {
libxslt.parse( xslStr, ( error, stylesheet ) => {
if ( error ) {
reject( error );
} else {
stylesheet.apply( xmlDoc, params, ( error, result ) => {
if ( error ) {
reject( error );
} else {
resolve( result );
}
} );
}
} );
} );
}
|
javascript
|
{
"resource": ""
}
|
q4601
|
_parseXml
|
train
|
function _parseXml( xmlStr ) {
let doc;
return new Promise( ( resolve, reject ) => {
try {
doc = libxmljs.parseXml( xmlStr );
resolve( doc );
} catch ( e ) {
reject( e );
}
} );
}
|
javascript
|
{
"resource": ""
}
|
q4602
|
_replaceTheme
|
train
|
function _replaceTheme( doc, theme ) {
const HAS_THEME = /(theme-)[^"'\s]+/;
if ( !theme ) {
return doc;
}
const formClassAttr = doc.root().get( '/root/form' ).attr( 'class' );
const formClassValue = formClassAttr.value();
if ( HAS_THEME.test( formClassValue ) ) {
formClassAttr.value( formClassValue.replace( HAS_THEME, `$1${theme}` ) );
} else {
formClassAttr.value( `${formClassValue} theme-${theme}` );
}
return doc;
}
|
javascript
|
{
"resource": ""
}
|
q4603
|
_replaceMediaSources
|
train
|
function _replaceMediaSources( xmlDoc, mediaMap ) {
if ( !mediaMap ) {
return xmlDoc;
}
// iterate through each element with a src attribute
xmlDoc.find( '//*[@src] | //a[@href]' ).forEach( mediaEl => {
const attribute = ( mediaEl.name().toLowerCase() === 'a' ) ? 'href' : 'src';
const src = mediaEl.attr( attribute ).value();
const matches = src ? src.match( /jr:\/\/[\w-]+\/(.+)/ ) : null;
const filename = matches && matches.length ? matches[ 1 ] : null;
const replacement = filename ? mediaMap[ filename ] : null;
if ( replacement ) {
mediaEl.attr( attribute, replacement );
}
} );
// add form logo <img> element if applicable
const formLogo = mediaMap[ 'form_logo.png' ];
const formLogoEl = xmlDoc.get( '//*[@class="form-logo"]' );
if ( formLogo && formLogoEl ) {
formLogoEl
.node( 'img' )
.attr( 'src', formLogo )
.attr( 'alt', 'form logo' );
}
return xmlDoc;
}
|
javascript
|
{
"resource": ""
}
|
q4604
|
_replaceLanguageTags
|
train
|
function _replaceLanguageTags( doc, survey ) {
const map = {};
const languageElements = doc.find( '/root/form/select[@id="form-languages"]/option' );
// List of parsed language objects
const languages = languageElements.map( el => {
const lang = el.text();
return language.parse( lang, _getLanguageSampleText( doc, lang ) );
} );
// forms without itext and only one language, still need directionality info
if ( languages.length === 0 ) {
languages.push( language.parse( '', _getLanguageSampleText( doc, '' ) ) );
}
// add or correct dir and value attributes, and amend textcontent of options in language selector
languageElements.forEach( ( el, index ) => {
const val = el.attr( 'value' ).value();
if ( val && val !== languages[ index ].tag ) {
map[ val ] = languages[ index ].tag;
}
el.attr( {
'data-dir': languages[ index ].dir,
'value': languages[ index ].tag
} ).text( languages[ index ].desc );
} );
// correct lang attributes
languages.forEach( lang => {
if ( lang.src === lang.tag ) {
return;
}
doc.find( `/root/form//*[@lang="${lang.src}"]` ).forEach( el => {
el.attr( {
lang: lang.tag
} );
} );
} );
// correct default lang attribute
const langSelectorElement = doc.get( '/root/form/*[@data-default-lang]' );
if ( langSelectorElement ) {
const defaultLang = langSelectorElement.attr( 'data-default-lang' ).value();
languages.some( lang => {
if ( lang.src === defaultLang ) {
langSelectorElement.attr( {
'data-default-lang': lang.tag
} );
return true;
}
return false;
} );
}
survey.languageMap = map;
return doc;
}
|
javascript
|
{
"resource": ""
}
|
q4605
|
_getLanguageSampleText
|
train
|
function _getLanguageSampleText( doc, lang ) {
// First find non-empty text content of a hint with that lang attribute.
// If not found, find any span with that lang attribute.
const langSampleEl = doc.get( `/root/form//span[contains(@class, "or-hint") and @lang="${lang}" and normalize-space() and not(./text() = '-')]` ) ||
doc.get( `/root/form//span[@lang="${lang}" and normalize-space() and not(./text() = '-')]` );
return ( langSampleEl && langSampleEl.text().trim().length ) ? langSampleEl.text() : 'nothing';
}
|
javascript
|
{
"resource": ""
}
|
q4606
|
_renderMarkdown
|
train
|
function _renderMarkdown( htmlDoc ) {
const replacements = {};
// First turn all outputs into text so *<span class="or-output></span>* can be detected
htmlDoc.find( '/root/form//span[contains(@class, "or-output")]' ).forEach( ( el, index ) => {
const key = `---output-${index}`;
const textNode = el.childNodes()[ 0 ].clone();
replacements[ key ] = el.toString();
textNode.text( key );
el.replace( textNode );
// Note that we end up in a situation where we likely have sibling text nodes...
} );
// Now render markdown
htmlDoc.find( '/root/form//span[contains(@class, "question-label") or contains(@class, "or-hint")]' ).forEach( ( el, index ) => {
let key;
/**
* Using text() is done because:
* a) We are certain that these <span>s do not contain other elements, other than formatting/markdown <span>s.
* b) This avoids the need to merge any sibling text nodes that could have been created in the previous step.
*
* Note that text() will convert > to >
*/
const original = el.text().replace( '<', '<' ).replace( '>', '>' );
const rendered = markdown.toHtml( original );
if ( original !== rendered ) {
key = `$$$${index}`;
replacements[ key ] = rendered;
el.text( key );
}
} );
// TODO: does this result in self-closing tags?
let htmlStr = _docToString( htmlDoc );
// Now replace the placeholders with the rendered HTML
// in reverse order so outputs are done last
Object.keys( replacements ).reverse().forEach( key => {
const replacement = replacements[ key ];
if ( replacement ) {
htmlStr = htmlStr.replace( key, replacement );
}
} );
return htmlStr;
}
|
javascript
|
{
"resource": ""
}
|
q4607
|
_md5
|
train
|
function _md5( message ) {
const hash = crypto.createHash( 'md5' );
hash.update( message );
return hash.digest( 'hex' );
}
|
javascript
|
{
"resource": ""
}
|
q4608
|
markdownToHtml
|
train
|
function markdownToHtml( text ) {
// note: in JS $ matches end of line as well as end of string, and ^ both beginning of line and string
const html = text
// html encoding of < because libXMLJs Element.text() converts html entities
.replace( /</gm, '<' )
// html encoding of < because libXMLJs Element.text() converts html entities
.replace( />/gm, '>' )
// span
.replace( /<\s?span([^/\n]*)>((?:(?!<\/).)+)<\/\s?span\s?>/gm, _createSpan )
// sup
.replace( /<\s?sup([^/\n]*)>((?:(?!<\/).)+)<\/\s?sup\s?>/gm, _createSup )
// sub
.replace( /<\s?sub([^/\n]*)>((?:(?!<\/).)+)<\/\s?sub\s?>/gm, _createSub )
// "\" will be used as escape character for *, _
.replace( /&/gm, '&' )
.replace( /\\\\/gm, '&92;' )
.replace( /\\\*/gm, '&42;' )
.replace( /\\_/gm, '&95;' )
.replace( /\\#/gm, '&35;' )
// strong
.replace( /__(.*?)__/gm, '<strong>$1</strong>' )
.replace( /\*\*(.*?)\*\*/gm, '<strong>$1</strong>' )
// emphasis
.replace( /_([^\s][^_\n]*)_/gm, '<em>$1</em>' )
.replace( /\*([^\s][^*\n]*)\*/gm, '<em>$1</em>' )
// links
.replace( /\[([^\]]*)\]\(([^)]+)\)/gm, '<a href="$2" target="_blank">$1</a>' )
// headers
.replace( /^\s*(#{1,6})\s?([^#][^\n]*)(\n|$)/gm, _createHeader )
// unordered lists
.replace( /(\n(\*|\+|-) (.*))+$/gm, _createUnorderedList )
// ordered lists
.replace( /(\n([0-9]+\.) (.*))+$/gm, _createOrderedList )
// reverting escape of special characters
.replace( /&35;/gm, '#' )
.replace( /&95;/gm, '_' )
.replace( /&92;/gm, '\\' )
.replace( /&42;/gm, '*' )
.replace( /&/gm, '&' )
// paragraphs
.replace( /([^\n]+)\n{2,}/gm, _createParagraph )
// any remaining newline characters
.replace( /([^\n]+)\n/gm, '$1<br>' );
return html;
}
|
javascript
|
{
"resource": ""
}
|
q4609
|
getLiveStream
|
train
|
function getLiveStream(options) {
return raspivid(Object.assign({
width: 960,
height: 540,
framerate: 20,
profile: 'baseline',
timeout: 0
}, options))
.pipe(new Splitter(NALseparator))
.pipe(new stream.Transform({ transform: function (chunk, encoding, callback) {
const chunkWithSeparator = Buffer.concat([NALseparator, chunk]);
const chunkType = chunk[0] & 0b11111;
// Capture the first SPS & PPS frames, so we can send stream parameters on connect.
if (chunkType === 7 || chunkType === 8) {
headerData.addParameterFrame(chunkWithSeparator);
} else {
// The live stream only includes the non-parameter chunks
this.push(chunkWithSeparator);
// Keep track of the latest IDR chunk, so we can start clients off with a near-current image
if (chunkType === 5) {
headerData.idrFrame = chunkWithSeparator;
}
}
callback();
}}));
}
|
javascript
|
{
"resource": ""
}
|
q4610
|
_request
|
train
|
function _request( options ) {
options.headers = options.headers || {};
options.headers[ 'X-OpenRosa-Version' ] = '1.0';
const method = options.method || 'get';
return new Promise( ( resolve, reject ) => {
request[ method ]( options, ( error, response, body ) => {
if ( error ) {
console.log( `Error occurred when requesting ${options.url}`, error );
reject( error );
} else if ( response.statusCode === 401 ) {
const error = new Error( 'Forbidden. Authorization Required.' );
error.status = response.statusCode;
reject( error );
} else if ( response.statusCode < 200 || response.statusCode >= 300 ) {
const error = new Error( `Request to ${options.url} failed.` );
error.status = response.statusCode;
reject( error );
} else {
console.log( `response of request to ${options.url} has status code: `, response.statusCode );
resolve( body );
}
} );
} );
}
|
javascript
|
{
"resource": ""
}
|
q4611
|
percentage
|
train
|
function percentage(num) {
const MAX_CHARACTERS = 4;
const relativePercentage = Math.ceil(num * 100 / (100 / MAX_CHARACTERS));
return `[${'▒'.repeat(relativePercentage)}${' '.repeat(MAX_CHARACTERS - relativePercentage)}]`;
}
|
javascript
|
{
"resource": ""
}
|
q4612
|
extend
|
train
|
function extend(obj, dft) {
if (obj == null) {
obj = {};
}
for (var k in dft) {
var v = dft[k];
if (obj[k] != null) {
continue;
}
obj[k] = v;
}
return obj;
}
|
javascript
|
{
"resource": ""
}
|
q4613
|
isBlank
|
train
|
function isBlank(char) {
return (char === ' ' ||
char === '\f' ||
char === '\n' ||
char === '\r' ||
char === '\t' ||
char === '\v' ||
char === '\u00A0' ||
char === '\u2028' ||
char === '\u2029');
}
|
javascript
|
{
"resource": ""
}
|
q4614
|
substr
|
train
|
function substr(astralSafeCharacterArray, len) {
// var boundary, cutted, result
var cutted = astralSafeCharacterArray.slice(0, len).join('');
if (!this.reserveLastWord) {
return cutted;
}
var boundary = astralSafeCharacterArray.slice(len - 1, len + 1).join('');
// if truncate at word boundary, just return
if (/\W/.test(boundary)) {
return cutted;
}
if (this.reserveLastWord < 0) {
var result = cutted.replace(/\w+$/, '');
// if the cutted is not the first and the only word
// then return result, or return the whole word
if (!(result.length === 0 && cutted.length === this.options.length)) {
return result;
}
}
// set max exceeded to 10 if this.reserveLastWord is true or > 0
var maxExceeded = this.reserveLastWord !== true && this.reserveLastWord > 0
? this.reserveLastWord
: 10;
var mtc = astralSafeCharacterArray.slice(len).join('').match(/(\w+)/);
var exceeded = mtc ? mtc[1] : '';
return cutted + exceeded.substr(0, maxExceeded);
}
|
javascript
|
{
"resource": ""
}
|
q4615
|
isCheerioInstance
|
train
|
function isCheerioInstance(elem) {
return elem &&
elem.contains &&
elem.html &&
elem.parseHTML && true;
}
|
javascript
|
{
"resource": ""
}
|
q4616
|
getScratch
|
train
|
function getScratch (eleOrCy, name) {
if (eleOrCy.scratch("_autopanOnDrag") === undefined) {
eleOrCy.scratch("_autopanOnDrag", {});
}
var scratchPad = eleOrCy.scratch("_autopanOnDrag");
return ( name === undefined ) ? scratchPad : scratchPad[name];
}
|
javascript
|
{
"resource": ""
}
|
q4617
|
filter
|
train
|
function filter(name, options) {
return utils.through.obj(function(file, enc, next) {
if (file.isNull()) {
next();
return;
}
var basename = path.basename(file.history[0]);
var stem = basename.slice(0, -3);
if (basename === name || stem === name) {
next(null, file);
} else {
next();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q4618
|
write
|
train
|
function write(path, str) {
fs.writeFile(path, str);
console.log(chalk.cyan(' create:'), path);
}
|
javascript
|
{
"resource": ""
}
|
q4619
|
readTemplate
|
train
|
function readTemplate(path) {
var template = fs.readFileSync(__dirname + '/templates/' + path, 'utf8');
for (var index in data) {
template = template.split('__' + index + '__').join(data[index]);
}
return template;
}
|
javascript
|
{
"resource": ""
}
|
q4620
|
mkdir
|
train
|
function mkdir(path, fn) {
shell.mkdir('-p', path);
shell.chmod(755, path);
console.log(chalk.cyan(' create:'), path);
if (fn) fn();
}
|
javascript
|
{
"resource": ""
}
|
q4621
|
train
|
function (store, evtName, handler) {
var args = [], len = arguments.length - 3;
while ( len-- > 0 ) args[ len ] = arguments[ len + 3 ];
this._riotx_change_handlers.push({
store: store,
evtName: evtName,
handler: handler
});
args.unshift(handler);
args.unshift(evtName);
store.change.apply(store, args);
}
|
javascript
|
{
"resource": ""
}
|
|
q4622
|
train
|
function () {
var this$1 = this;
// the context of `this` will be equal to riot tag instant.
this.on('unmount', function () {
this$1.off('*');
forEach_1(this$1._riotx_change_handlers, function (obj) {
obj.store.off(obj.evtName, obj.handler);
});
delete this$1.riotx;
delete this$1._riotx_change_handlers;
delete this$1[settings.changeBindName];
});
if (settings.debug) {
this.on('*', function (eventName) {
debug('[riot.mixin]', eventName, this$1);
});
}
this._riotx_change_handlers = [];
// let users set the name.
this[settings.changeBindName] = riotxChange;
}
|
javascript
|
{
"resource": ""
}
|
|
q4623
|
readFromStream
|
train
|
function readFromStream(stream, callback) {
var buf = [];
stream.on("data", onData);
stream.on("end", onEnd);
stream.on("error", onError);
function onData(data) {
buf.push(data);
}
function onEnd() {
if (callback) callback(null, buf.join(""));
callback = null;
}
function onError(err) {
if (callback) callback(err);
callback = null;
}
}
|
javascript
|
{
"resource": ""
}
|
q4624
|
train
|
function($scope) {
this.$scope = $scope;
this.$markdownInput = $scope.find(SELECTORS.MARKDOWN_INPUT);
this.$form = $scope.find(SELECTORS.FORM);
this.$titleInput = $scope.find(SELECTORS.TITLE_INPUT);
this.$deleteButton = $scope.find(SELECTORS.DELETE);
this.dropzone = new Dropzone(SELECTORS.DROPZONE);
this.simplemde = new SimpleMDE();
this.bind();
}
|
javascript
|
{
"resource": ""
}
|
|
q4625
|
train
|
function (file, responseText) {
console.log(responseText); // console should show the ID you pointed to
// read the upload path from the elements data-upload attribute.
var uploadPath = $(this.dropzone.element).data("upload") + responseText;
var linkToUploadedFile = "(" + uploadPath + ")";
if ( file.type.startsWith( "image/" ) ) {
linkToUploadedFile = "![]" + linkToUploadedFile;
} else {
linkToUploadedFile = "[" + responseText + "]" + linkToUploadedFile;
}
this.simplemde.value(this.simplemde.value() + "\n" + linkToUploadedFile + "\n");
}
|
javascript
|
{
"resource": ""
}
|
|
q4626
|
add
|
train
|
function add(css, name) {
if (name) { byName[name] = css; }
else { remainder.push(css); }
needsInject = true;
}
|
javascript
|
{
"resource": ""
}
|
q4627
|
styleObjectToString
|
train
|
function styleObjectToString(style) {
return Object.keys(style).reduce(function (acc, prop) {
return (acc + " " + prop + ": " + (style[prop]) + ";")
}, '')
}
|
javascript
|
{
"resource": ""
}
|
q4628
|
arrayishAdd
|
train
|
function arrayishAdd(obj, key, value, ensureArray, index) {
var dest = obj[key];
var isArr = isArray(dest);
var hasIndex = !isUndefined(index);
if (dest && dest === value) { return }
// if the key was never set, set it once
if (!dest && ensureArray) { obj[key] = [value]; }
else if (!dest) { obj[key] = value; }
// if it was an array and not yet set
else {
if (isArr) {
var oldIndex = dest.indexOf(value);
// this item never changed its position
if (oldIndex === index) { return }
// remove the item from its old position
if (oldIndex !== -1) { dest.splice(oldIndex, 1); }
// move or add the item
if (hasIndex) {
dest.splice(index, 0, value);
} else {
dest.push(value);
}
} else { obj[key] = [dest, value]; }
}
}
|
javascript
|
{
"resource": ""
}
|
q4629
|
arrayishRemove
|
train
|
function arrayishRemove(obj, key, value, ensureArray) {
if (isArray(obj[key])) {
var index = obj[key].indexOf(value);
if (index !== -1) { obj[key].splice(index, 1); }
if (!obj[key].length) { delete obj[key]; }
else if (obj[key].length === 1 && !ensureArray) { obj[key] = obj[key][0]; }
} else if (obj[key] === value)
{ delete obj[key]; } // otherwise just delete the key
}
|
javascript
|
{
"resource": ""
}
|
q4630
|
makeReplaceVirtual
|
train
|
function makeReplaceVirtual(tag, ref) {
var frag = createFragment();
makeVirtual.call(tag, frag);
ref.parentNode.replaceChild(frag, ref);
}
|
javascript
|
{
"resource": ""
}
|
q4631
|
normalizeAttrName
|
train
|
function normalizeAttrName(attrName) {
if (!attrName) { return null }
attrName = attrName.replace(ATTRS_PREFIX, '');
if (CASE_SENSITIVE_ATTRIBUTES[attrName]) { attrName = CASE_SENSITIVE_ATTRIBUTES[attrName]; }
return attrName
}
|
javascript
|
{
"resource": ""
}
|
q4632
|
updateOpts
|
train
|
function updateOpts(isLoop, parent, isAnonymous, opts, instAttrs) {
// isAnonymous `each` tags treat `dom` and `root` differently. In this case
// (and only this case) we don't need to do updateOpts, because the regular parse
// will update those attrs. Plus, isAnonymous tags don't need opts anyway
if (isLoop && isAnonymous) { return }
var ctx = isLoop ? inheritParentProps.call(this) : parent || this;
each(instAttrs, function (attr) {
if (attr.expr) { updateExpression.call(ctx, attr.expr); }
// normalize the attribute names
opts[toCamel(attr.name).replace(ATTRS_PREFIX, '')] = attr.expr ? attr.expr.value : attr.value;
});
}
|
javascript
|
{
"resource": ""
}
|
q4633
|
componentUpdate
|
train
|
function componentUpdate(tag, data, expressions) {
var __ = tag.__;
var nextOpts = {};
var canTrigger = tag.isMounted && !__.skipAnonymous;
// inherit properties from the parent tag
if (__.isAnonymous && __.parent) { extend(tag, __.parent); }
extend(tag, data);
updateOpts.apply(tag, [__.isLoop, __.parent, __.isAnonymous, nextOpts, __.instAttrs]);
if (
canTrigger &&
tag.isMounted &&
isFunction$1(tag.shouldUpdate) && !tag.shouldUpdate(data, nextOpts)
) {
return tag
}
extend(tag.opts, nextOpts);
if (canTrigger) { tag.trigger('update', data); }
update.call(tag, expressions);
if (canTrigger) { tag.trigger('updated'); }
return tag
}
|
javascript
|
{
"resource": ""
}
|
q4634
|
componentMixin
|
train
|
function componentMixin(tag$$1) {
var mixins = [], len = arguments.length - 1;
while ( len-- > 0 ) mixins[ len ] = arguments[ len + 1 ];
each(mixins, function (mix) {
var instance;
var obj;
var props = [];
// properties blacklisted and will not be bound to the tag instance
var propsBlacklist = ['init', '__proto__'];
mix = isString(mix) ? mixin(mix) : mix;
// check if the mixin is a function
if (isFunction$1(mix)) {
// create the new mixin instance
instance = new mix();
} else { instance = mix; }
var proto = Object.getPrototypeOf(instance);
// build multilevel prototype inheritance chain property list
do { props = props.concat(Object.getOwnPropertyNames(obj || instance)); }
while (obj = Object.getPrototypeOf(obj || instance))
// loop the keys in the function prototype or the all object keys
each(props, function (key) {
// bind methods to tag
// allow mixins to override other properties/parent mixins
if (!contains(propsBlacklist, key)) {
// check for getters/setters
var descriptor = getPropDescriptor(instance, key) || getPropDescriptor(proto, key);
var hasGetterSetter = descriptor && (descriptor.get || descriptor.set);
// apply method only if it does not already exist on the instance
if (!tag$$1.hasOwnProperty(key) && hasGetterSetter) {
Object.defineProperty(tag$$1, key, descriptor);
} else {
tag$$1[key] = isFunction$1(instance[key]) ?
instance[key].bind(tag$$1) :
instance[key];
}
}
});
// init method will be called automatically
if (instance.init)
{ instance.init.bind(tag$$1)(tag$$1.opts); }
});
return tag$$1
}
|
javascript
|
{
"resource": ""
}
|
q4635
|
remove
|
train
|
function remove(tags, i) {
tags.splice(i, 1);
this.unmount();
arrayishRemove(this.parent, this, this.__.tagName, true);
}
|
javascript
|
{
"resource": ""
}
|
q4636
|
move
|
train
|
function move(root, nextTag, isVirtual) {
if (isVirtual)
{ moveVirtual.apply(this, [root, nextTag]); }
else
{ safeInsert(root, this.root, nextTag.root); }
}
|
javascript
|
{
"resource": ""
}
|
q4637
|
insert
|
train
|
function insert(root, nextTag, isVirtual) {
if (isVirtual)
{ makeVirtual.apply(this, [root, nextTag]); }
else
{ safeInsert(root, this.root, nextTag.root); }
}
|
javascript
|
{
"resource": ""
}
|
q4638
|
append
|
train
|
function append(root, isVirtual) {
if (isVirtual)
{ makeVirtual.call(this, root); }
else
{ root.appendChild(this.root); }
}
|
javascript
|
{
"resource": ""
}
|
q4639
|
getItemId
|
train
|
function getItemId(keyAttr, originalItem, keyedItem, hasKeyAttrExpr) {
if (keyAttr) {
return hasKeyAttrExpr ? tmpl(keyAttr, keyedItem) : originalItem[keyAttr]
}
return originalItem
}
|
javascript
|
{
"resource": ""
}
|
q4640
|
createRefDirective
|
train
|
function createRefDirective(dom, tag, attrName, attrValue) {
return create(RefExpr).init(dom, tag, attrName, attrValue)
}
|
javascript
|
{
"resource": ""
}
|
q4641
|
createIfDirective
|
train
|
function createIfDirective(dom, tag, attr) {
return create(IfExpr).init(dom, tag, attr)
}
|
javascript
|
{
"resource": ""
}
|
q4642
|
parseExpressions
|
train
|
function parseExpressions(root, mustIncludeRoot) {
var this$1 = this;
var expressions = [];
walkNodes(root, function (dom) {
var type = dom.nodeType;
var attr;
var tagImpl;
if (!mustIncludeRoot && dom === root) { return }
// text node
if (type === 3 && dom.parentNode.tagName !== 'STYLE' && tmpl.hasExpr(dom.nodeValue))
{ expressions.push({dom: dom, expr: dom.nodeValue}); }
if (type !== 1) { return }
var isVirtual = dom.tagName === 'VIRTUAL';
// loop. each does it's own thing (for now)
if (attr = getAttribute(dom, LOOP_DIRECTIVE)) {
if(isVirtual) { setAttribute(dom, 'loopVirtual', true); } // ignore here, handled in _each
expressions.push(_each(dom, this$1, attr));
return false
}
// if-attrs become the new parent. Any following expressions (either on the current
// element, or below it) become children of this expression.
if (attr = getAttribute(dom, CONDITIONAL_DIRECTIVE)) {
expressions.push(createIfDirective(dom, this$1, attr));
return false
}
if (attr = getAttribute(dom, IS_DIRECTIVE)) {
if (tmpl.hasExpr(attr)) {
expressions.push({
isRtag: true,
expr: attr,
dom: dom,
attrs: [].slice.call(dom.attributes)
});
return false
}
}
// if this is a tag, stop traversing here.
// we ignore the root, since parseExpressions is called while we're mounting that root
tagImpl = get(dom);
if(isVirtual) {
if(getAttribute(dom, 'virtualized')) {dom.parentElement.removeChild(dom); } // tag created, remove from dom
if(!tagImpl && !getAttribute(dom, 'virtualized') && !getAttribute(dom, 'loopVirtual')) // ok to create virtual tag
{ tagImpl = { tmpl: dom.outerHTML }; }
}
if (tagImpl && (dom !== root || mustIncludeRoot)) {
if(isVirtual) { // handled in update
if (getAttribute(dom, IS_DIRECTIVE))
{ warn(("Virtual tags shouldn't be used together with the \"" + IS_DIRECTIVE + "\" attribute - https://github.com/riot/riot/issues/2511")); }
// can not remove attribute like directives
// so flag for removal after creation to prevent maximum stack error
setAttribute(dom, 'virtualized', true);
var tag = createTag(
{tmpl: dom.outerHTML},
{root: dom, parent: this$1},
dom.innerHTML
);
expressions.push(tag); // no return, anonymous tag, keep parsing
} else {
expressions.push(
initChild(
tagImpl,
{
root: dom,
parent: this$1
},
dom.innerHTML,
this$1
)
);
return false
}
}
// attribute expressions
parseAttributes.apply(this$1, [dom, dom.attributes, function (attr, expr) {
if (!expr) { return }
expressions.push(expr);
}]);
});
return expressions
}
|
javascript
|
{
"resource": ""
}
|
q4643
|
setMountState
|
train
|
function setMountState(value) {
var ref = this.__;
var isAnonymous = ref.isAnonymous;
define(this, 'isMounted', value);
if (!isAnonymous) {
if (value) { this.trigger('mount'); }
else {
this.trigger('unmount');
this.off('*');
this.__.wasCreated = false;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q4644
|
componentMount
|
train
|
function componentMount(tag$$1, dom, expressions, opts) {
var __ = tag$$1.__;
var root = __.root;
root._tag = tag$$1; // keep a reference to the tag just created
// Read all the attrs on this instance. This give us the info we need for updateOpts
parseAttributes.apply(__.parent, [root, root.attributes, function (attr, expr) {
if (!__.isAnonymous && RefExpr.isPrototypeOf(expr)) { expr.tag = tag$$1; }
attr.expr = expr;
__.instAttrs.push(attr);
}]);
// update the root adding custom attributes coming from the compiler
walkAttributes(__.impl.attrs, function (k, v) { __.implAttrs.push({name: k, value: v}); });
parseAttributes.apply(tag$$1, [root, __.implAttrs, function (attr, expr) {
if (expr) { expressions.push(expr); }
else { setAttribute(root, attr.name, attr.value); }
}]);
// initialiation
updateOpts.apply(tag$$1, [__.isLoop, __.parent, __.isAnonymous, opts, __.instAttrs]);
// add global mixins
var globalMixin = mixin(GLOBAL_MIXIN);
if (globalMixin && !__.skipAnonymous) {
for (var i in globalMixin) {
if (globalMixin.hasOwnProperty(i)) {
tag$$1.mixin(globalMixin[i]);
}
}
}
if (__.impl.fn) { __.impl.fn.call(tag$$1, opts); }
if (!__.skipAnonymous) { tag$$1.trigger('before-mount'); }
// parse layout after init. fn may calculate args for nested custom tags
each(parseExpressions.apply(tag$$1, [dom, __.isAnonymous]), function (e) { return expressions.push(e); });
tag$$1.update(__.item);
if (!__.isAnonymous && !__.isInline) {
while (dom.firstChild) { root.appendChild(dom.firstChild); }
}
define(tag$$1, 'root', root);
// if we need to wait that the parent "mount" or "updated" event gets triggered
if (!__.skipAnonymous && tag$$1.parent) {
var p = getImmediateCustomParent(tag$$1.parent);
p.one(!p.isMounted ? 'mount' : 'updated', function () {
setMountState.call(tag$$1, true);
});
} else {
// otherwise it's not a child tag we can trigger its mount event
setMountState.call(tag$$1, true);
}
tag$$1.__.wasCreated = true;
return tag$$1
}
|
javascript
|
{
"resource": ""
}
|
q4645
|
tagUnmount
|
train
|
function tagUnmount(tag, mustKeepRoot, expressions) {
var __ = tag.__;
var root = __.root;
var tagIndex = __TAGS_CACHE.indexOf(tag);
var p = root.parentNode;
if (!__.skipAnonymous) { tag.trigger('before-unmount'); }
// clear all attributes coming from the mounted tag
walkAttributes(__.impl.attrs, function (name) {
if (startsWith(name, ATTRS_PREFIX))
{ name = name.slice(ATTRS_PREFIX.length); }
removeAttribute(root, name);
});
// remove all the event listeners
tag.__.listeners.forEach(function (dom) {
Object.keys(dom[RIOT_EVENTS_KEY]).forEach(function (eventName) {
dom.removeEventListener(eventName, dom[RIOT_EVENTS_KEY][eventName]);
});
});
// remove tag instance from the global tags cache collection
if (tagIndex !== -1) { __TAGS_CACHE.splice(tagIndex, 1); }
// clean up the parent tags object
if (__.parent && !__.isAnonymous) {
var ptag = getImmediateCustomParent(__.parent);
if (__.isVirtual) {
Object
.keys(tag.tags)
.forEach(function (tagName) { return arrayishRemove(ptag.tags, tagName, tag.tags[tagName]); });
} else {
arrayishRemove(ptag.tags, __.tagName, tag);
}
}
// unmount all the virtual directives
if (tag.__.virts) {
each(tag.__.virts, function (v) {
if (v.parentNode) { v.parentNode.removeChild(v); }
});
}
// allow expressions to unmount themselves
unmountAll(expressions);
each(__.instAttrs, function (a) { return a.expr && a.expr.unmount && a.expr.unmount(); });
// clear the tag html if it's necessary
if (mustKeepRoot) { setInnerHTML(root, ''); }
// otherwise detach the root tag from the DOM
else if (p) { p.removeChild(root); }
// custom internal unmount function to avoid relying on the observable
if (__.onUnmount) { __.onUnmount(); }
// weird fix for a weird edge case #2409 and #2436
// some users might use your software not as you've expected
// so I need to add these dirty hacks to mitigate unexpected issues
if (!tag.isMounted) { setMountState.call(tag, true); }
setMountState.call(tag, false);
delete root._tag;
return tag
}
|
javascript
|
{
"resource": ""
}
|
q4646
|
train
|
function () {
var args = [], len = arguments.length;
while ( len-- ) args[ len ] = arguments[ len ];
if (!settings$2.debug) {
return;
}
args.unshift('DEBUG');
settings$2.logger.output.apply(null, args);
}
|
javascript
|
{
"resource": ""
}
|
|
q4647
|
injectKineticProperties
|
train
|
function injectKineticProperties (kineticConfig,
kineticHierarchy,
kineticEvents) {
for (var type in kineticHierarchy) {
var parents = kineticHierarchy[type];
KineticProperty.getParents[type] = [type].concat(parents);
for (var pi in parents) {
var parent = parents[pi];
var existingChildren = KineticProperty.getChildren[parent] || [];
existingChildren.push(type);
KineticProperty.getChildren[parent] = existingChildren;
}
}
for (var propI in kineticConfig) {
var data = kineticConfig[propI];
var propName = data.propName;
var propType = data.type;
var defaultValue = data.defaultValue;
var nodeType = data.nodeType;
var children = [nodeType].concat(
KineticProperty.getChildren[nodeType] || []
);
for (var ci in children) {
var child = children[ci];
var existingProps = KineticProperty.getValidProps[child] || {};
existingProps[propName] = {
type: propType,
defaultValue: defaultValue
};
KineticProperty.getValidProps[child] = existingProps;
}
}
for (var eventName in kineticEvents) {
KineticProperty.getEventName[eventName] = kineticEvents[eventName] +
"." + "react";
}
}
|
javascript
|
{
"resource": ""
}
|
q4648
|
train
|
function() {
var d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
var m0 = this.m[3] * d;
var m1 = -this.m[1] * d;
var m2 = -this.m[2] * d;
var m3 = this.m[0] * d;
var m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
var m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
this.m[0] = m0;
this.m[1] = m1;
this.m[2] = m2;
this.m[3] = m3;
this.m[4] = m4;
this.m[5] = m5;
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4649
|
train
|
function(x, y) {
var m0 = this.m[0],
m1 = this.m[1],
m2 = this.m[2],
m3 = this.m[3],
m4 = this.m[4],
m5 = this.m[5],
yt = ((m0 * (y - m5)) - (m1 * (x - m4))) / ((m0 * m3) - (m1 * m2)),
xt = (x - m4 - (m2 * yt)) / m0;
return this.translate(xt, yt);
}
|
javascript
|
{
"resource": ""
}
|
|
q4650
|
train
|
function() {
var randColor = (Math.random() * 0xFFFFFF << 0).toString(16);
while (randColor.length < 6) {
randColor = ZERO + randColor;
}
return HASH + randColor;
}
|
javascript
|
{
"resource": ""
}
|
|
q4651
|
train
|
function(color) {
var rgb;
// color string
if (color in COLORS) {
rgb = COLORS[color];
return {
r: rgb[0],
g: rgb[1],
b: rgb[2]
};
}
// hex
else if (color[0] === HASH) {
return this._hexToRgb(color.substring(1));
}
// rgb string
else if (color.substr(0, 4) === RGB_PAREN) {
rgb = RGB_REGEX.exec(color.replace(/ /g,''));
return {
r: parseInt(rgb[1], 10),
g: parseInt(rgb[2], 10),
b: parseInt(rgb[3], 10)
};
}
// default
else {
return {
r: 0,
g: 0,
b: 0
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4652
|
train
|
function(o1, o2) {
var retObj = this._clone(o2);
for(var key in o1) {
if(this._isObject(o1[key])) {
retObj[key] = this._merge(o1[key], retObj[key]);
}
else {
retObj[key] = o1[key];
}
}
return retObj;
}
|
javascript
|
{
"resource": ""
}
|
|
q4653
|
train
|
function(constructor, methods) {
var key;
for (key in methods) {
constructor.prototype[key] = methods[key];
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4654
|
train
|
function(mimeType, quality) {
try {
// If this call fails (due to browser bug, like in Firefox 3.6),
// then revert to previous no-parameter image/png behavior
return this._canvas.toDataURL(mimeType, quality);
}
catch(e) {
try {
return this._canvas.toDataURL();
}
catch(err) {
Kinetic.Util.warn('Unable to get data URL. ' + err.message);
return '';
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4655
|
train
|
function(shape) {
var fillEnabled = shape.getFillEnabled();
if(fillEnabled) {
this._fill(shape);
}
if(shape.getStrokeEnabled()) {
this._stroke(shape);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4656
|
train
|
function(relaxed) {
var traceArr = this.traceArr,
len = traceArr.length,
str = '',
n, trace, method, args;
for (n=0; n<len; n++) {
trace = traceArr[n];
method = trace.method;
// methods
if (method) {
args = trace.args;
str += method;
if (relaxed) {
str += DOUBLE_PAREN;
}
else {
if (Kinetic.Util._isArray(args[0])) {
str += OPEN_PAREN_BRACKET + args.join(COMMA) + CLOSE_BRACKET_PAREN;
}
else {
str += OPEN_PAREN + args.join(COMMA) + CLOSE_PAREN;
}
}
}
// properties
else {
str += trace.property;
if (!relaxed) {
str += EQUALS + trace.val;
}
}
str += SEMICOLON;
}
return str;
}
|
javascript
|
{
"resource": ""
}
|
|
q4657
|
train
|
function() {
var a = arguments;
this._context.arc(a[0], a[1], a[2], a[3], a[4], a[5]);
}
|
javascript
|
{
"resource": ""
}
|
|
q4658
|
train
|
function(methodName) {
var origMethod = that[methodName],
ret;
that[methodName] = function() {
args = _simplifyArray(Array.prototype.slice.call(arguments, 0));
ret = origMethod.apply(that, arguments);
that._trace({
method: methodName,
args: args
});
return ret;
};
}
|
javascript
|
{
"resource": ""
}
|
|
q4659
|
train
|
function(evt) {
var e = {
target: this,
type: evt.type,
evt: evt
};
this.fire(evt.type, e);
}
|
javascript
|
{
"resource": ""
}
|
|
q4660
|
train
|
function() {
var parent = this.getParent();
if(parent && parent.children) {
parent.children.splice(this.index, 1);
parent._setChildrenIndices();
delete this.parent;
}
// every cached attr that is calculated via node tree
// traversal must be cleared when removing a node
this._clearSelfAndDescendantCache(STAGE);
this._clearSelfAndDescendantCache(ABSOLUTE_TRANSFORM);
this._clearSelfAndDescendantCache(VISIBLE);
this._clearSelfAndDescendantCache(LISTENING);
this._clearSelfAndDescendantCache(ABSOLUTE_OPACITY);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4661
|
train
|
function(config) {
var key, method;
if(config) {
for(key in config) {
if (key === CHILDREN) {
}
else {
method = SET + Kinetic.Util._capitalize(key);
// use setter if available
if(Kinetic.Util._isFunction(this[method])) {
this[method](config[key]);
}
// otherwise set directly
else {
this._setAttr(key, config[key]);
}
}
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4662
|
train
|
function() {
var depth = this.getDepth(),
that = this,
index = 0,
nodes, len, n, child;
function addChildren(children) {
nodes = [];
len = children.length;
for(n = 0; n < len; n++) {
child = children[n];
index++;
if(child.nodeType !== SHAPE) {
nodes = nodes.concat(child.getChildren().toArray());
}
if(child._id === that._id) {
n = len;
}
}
if(nodes.length > 0 && nodes[0].getDepth() <= depth) {
addChildren(nodes);
}
}
if(that.nodeType !== UPPER_STAGE) {
addChildren(that.getStage().getChildren());
}
return index;
}
|
javascript
|
{
"resource": ""
}
|
|
q4663
|
train
|
function() {
var absoluteMatrix = this.getAbsoluteTransform().getMatrix(),
absoluteTransform = new Kinetic.Transform(),
offset = this.offset();
// clone the matrix array
absoluteTransform.m = absoluteMatrix.slice();
absoluteTransform.translate(offset.x, offset.y);
return absoluteTransform.getTranslation();
}
|
javascript
|
{
"resource": ""
}
|
|
q4664
|
train
|
function(pos) {
var origTrans = this._clearTransform(),
it;
// don't clear translation
this.attrs.x = origTrans.x;
this.attrs.y = origTrans.y;
delete origTrans.x;
delete origTrans.y;
// unravel transform
it = this.getAbsoluteTransform();
it.invert();
it.translate(pos.x, pos.y);
pos = {
x: this.attrs.x + it.getTranslation().x,
y: this.attrs.y + it.getTranslation().y
};
this.setPosition({x:pos.x, y:pos.y});
this._setTransform(origTrans);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4665
|
train
|
function(change) {
var changeX = change.x,
changeY = change.y,
x = this.getX(),
y = this.getY();
if(changeX !== undefined) {
x += changeX;
}
if(changeY !== undefined) {
y += changeY;
}
this.setPosition({x:x, y:y});
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4666
|
train
|
function() {
if (!this.parent) {
Kinetic.Util.warn('Node has no parent. moveToTop function is ignored.');
return;
}
var index = this.index;
this.parent.children.splice(index, 1);
this.parent.children.push(this);
this.parent._setChildrenIndices();
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4667
|
train
|
function() {
if (!this.parent) {
Kinetic.Util.warn('Node has no parent. moveUp function is ignored.');
return;
}
var index = this.index,
len = this.parent.getChildren().length;
if(index < len - 1) {
this.parent.children.splice(index, 1);
this.parent.children.splice(index + 1, 0, this);
this.parent._setChildrenIndices();
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q4668
|
train
|
function(zIndex) {
if (!this.parent) {
Kinetic.Util.warn('Node has no parent. zIndex parameter is ignored.');
return;
}
var index = this.index;
this.parent.children.splice(index, 1);
this.parent.children.splice(zIndex, 0, this);
this.parent._setChildrenIndices();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4669
|
train
|
function() {
var type = Kinetic.Util,
obj = {},
attrs = this.getAttrs(),
key, val, getter, defaultValue;
obj.attrs = {};
// serialize only attributes that are not function, image, DOM, or objects with methods
for(key in attrs) {
val = attrs[key];
if (!type._isFunction(val) && !type._isElement(val) && !(type._isObject(val) && type._hasMethods(val))) {
getter = this[key];
// remove attr value so that we can extract the default value from the getter
delete attrs[key];
defaultValue = getter ? getter.call(this) : null;
// restore attr value
attrs[key] = val;
if (defaultValue !== val) {
obj.attrs[key] = val;
}
}
}
obj.className = this.getClassName();
return obj;
}
|
javascript
|
{
"resource": ""
}
|
|
q4670
|
train
|
function(config) {
Kinetic.Util._getImage(this.toDataURL(config), function(img) {
config.callback(img);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q4671
|
train
|
function(layers) {
var lays = [];
// if passing in no layers
if (!layers) {
lays = [];
}
// if passing in an array of Layers
// NOTE: layers could be an array or Kinetic.Collection. for simplicity, I'm just inspecting
// the length property to check for both cases
else if (layers.length > 0) {
lays = layers;
}
// if passing in a Layer
else {
lays = [layers];
}
this.layers = lays;
}
|
javascript
|
{
"resource": ""
}
|
|
q4672
|
train
|
function(layer) {
var layers = this.layers,
len, n;
if (layers) {
len = layers.length;
// don't add the layer if it already exists
for (n = 0; n < len; n++) {
if (layers[n]._id === layer._id) {
return false;
}
}
}
else {
this.layers = [];
}
this.layers.push(layer);
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q4673
|
train
|
function() {
var a = Kinetic.Animation,
animations = a.animations,
len = animations.length,
n;
for(n = 0; n < len; n++) {
if(animations[n].id === this.id) {
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q4674
|
train
|
function(t, b, c, d) {
return c - Kinetic.Easings.BounceEaseOut(d - t, 0, c, d) + b;
}
|
javascript
|
{
"resource": ""
}
|
|
q4675
|
train
|
function(t, b, c, d) {
if(t < d / 2) {
return Kinetic.Easings.BounceEaseIn(t * 2, 0, c, d) * 0.5 + b;
}
else {
return Kinetic.Easings.BounceEaseOut(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4676
|
train
|
function() {
var children = Kinetic.Collection.toCollection(this.children);
var child;
for (var i = 0; i < children.length; i++) {
child = children[i];
// reset parent to prevent many _setChildrenIndices calls
delete child.parent;
child.index = 0;
if (child.hasChildren()) {
child.removeChildren();
}
child.remove();
}
children = null;
this.children = new Kinetic.Collection();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4677
|
train
|
function() {
var children = Kinetic.Collection.toCollection(this.children);
var child;
for (var i = 0; i < children.length; i++) {
child = children[i];
// reset parent to prevent many _setChildrenIndices calls
delete child.parent;
child.index = 0;
child.destroy();
}
children = null;
this.children = new Kinetic.Collection();
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4678
|
train
|
function(child) {
if (arguments.length > 1) {
for (var i = 0; i < arguments.length; i++) {
this.add(arguments[i]);
}
return;
}
if (child.getParent()) {
child.moveTo(this);
return;
}
var children = this.children;
this._validateAdd(child);
child.index = children.length;
child.parent = this;
children.push(child);
this._fire('add', {
child: child
});
// chainable
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4679
|
train
|
function(node) {
var parent = node.getParent();
while(parent) {
if(parent._id === this._id) {
return true;
}
parent = parent.getParent();
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q4680
|
train
|
function(alphaThreshold) {
var threshold = alphaThreshold || 0,
cachedCanvas = this._cache.canvas,
sceneCanvas = this._getCachedSceneCanvas(),
sceneContext = sceneCanvas.getContext(),
hitCanvas = cachedCanvas.hit,
hitContext = hitCanvas.getContext(),
width = sceneCanvas.getWidth(),
height = sceneCanvas.getHeight(),
sceneImageData, sceneData, hitImageData, hitData, len, rgbColorKey, i, alpha;
hitContext.clear();
try {
sceneImageData = sceneContext.getImageData(0, 0, width, height);
sceneData = sceneImageData.data;
hitImageData = hitContext.getImageData(0, 0, width, height);
hitData = hitImageData.data;
len = sceneData.length;
rgbColorKey = Kinetic.Util._hexToRgb(this.colorKey);
// replace non transparent pixels with color key
for(i = 0; i < len; i += 4) {
alpha = sceneData[i + 3];
if (alpha > threshold) {
hitData[i] = rgbColorKey.r;
hitData[i + 1] = rgbColorKey.g;
hitData[i + 2] = rgbColorKey.b;
hitData[i + 3] = 255;
}
}
hitContext.putImageData(hitImageData, 0, 0);
}
catch(e) {
Kinetic.Util.warn('Unable to draw hit graph from cached scene canvas. ' + e.message);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4681
|
train
|
function(container) {
if( typeof container === STRING) {
var id = container;
container = Kinetic.document.getElementById(container);
if (!container) {
throw 'Can not find container in document with id ' + id;
}
}
this._setAttr(CONTAINER, container);
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4682
|
train
|
function() {
var layers = this.children,
len = layers.length,
n;
for(n = 0; n < len; n++) {
layers[n].clear();
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4683
|
train
|
function(config) {
config = config || {};
var mimeType = config.mimeType || null,
quality = config.quality || null,
x = config.x || 0,
y = config.y || 0,
canvas = new Kinetic.SceneCanvas({
width: config.width || this.getWidth(),
height: config.height || this.getHeight(),
pixelRatio: 1
}),
_context = canvas.getContext()._context,
layers = this.children;
if(x || y) {
_context.translate(-1 * x, -1 * y);
}
function drawLayer(n) {
var layer = layers[n],
layerUrl = layer.toDataURL(),
imageObj = new Kinetic.window.Image();
imageObj.onload = function() {
_context.drawImage(imageObj, 0, 0);
if(n < layers.length - 1) {
drawLayer(n + 1);
}
else {
config.callback(canvas.toDataURL(mimeType, quality));
}
};
imageObj.src = layerUrl;
}
drawLayer(0);
}
|
javascript
|
{
"resource": ""
}
|
|
q4684
|
train
|
function(config) {
var cb = config.callback;
config.callback = function(dataUrl) {
Kinetic.Util._getImage(dataUrl, function(img) {
cb(img);
});
};
this.toDataURL(config);
}
|
javascript
|
{
"resource": ""
}
|
|
q4685
|
train
|
function(layer) {
if (arguments.length > 1) {
for (var i = 0; i < arguments.length; i++) {
this.add(arguments[i]);
}
return;
}
Kinetic.Container.prototype.add.call(this, layer);
layer._setCanvasSize(this.width(), this.height());
// draw layer and append canvas to container
layer.draw();
this.content.appendChild(layer.canvas._canvas);
// chainable
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4686
|
train
|
function(index) {
Kinetic.Node.prototype.setZIndex.call(this, index);
var stage = this.getStage();
if(stage) {
stage.content.removeChild(this.getCanvas()._canvas);
if(index < stage.getChildren().length - 1) {
stage.content.insertBefore(this.getCanvas()._canvas, stage.getChildren()[index + 1].getCanvas()._canvas);
}
else {
stage.content.appendChild(this.getCanvas()._canvas);
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q4687
|
train
|
function() {
Kinetic.Node.prototype.moveToTop.call(this);
var stage = this.getStage();
if(stage) {
stage.content.removeChild(this.getCanvas()._canvas);
stage.content.appendChild(this.getCanvas()._canvas);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4688
|
train
|
function() {
if(Kinetic.Node.prototype.moveDown.call(this)) {
var stage = this.getStage();
if(stage) {
var children = stage.getChildren();
stage.content.removeChild(this.getCanvas()._canvas);
stage.content.insertBefore(this.getCanvas()._canvas, children[this.index + 1].getCanvas()._canvas);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q4689
|
train
|
function() {
return this.attrs.height === AUTO ? (this.getTextHeight() * this.textArr.length * this.getLineHeight()) + this.getPadding() * 2 : this.attrs.height;
}
|
javascript
|
{
"resource": ""
}
|
|
q4690
|
loadSample
|
train
|
function loadSample(url, doAfterLoading) {
var fetchSound = new XMLHttpRequest(); // Load the Sound with XMLHttpRequest
fetchSound.open("GET", url, true); // Path to Audio File
fetchSound.responseType = "arraybuffer"; // Read as Binary Data
fetchSound.onload = function() {
context.decodeAudioData(fetchSound.response, doAfterLoading);
}
fetchSound.send();
}
|
javascript
|
{
"resource": ""
}
|
q4691
|
execute
|
train
|
function execute (configs, fn, ...args) {
if ('verbose' in configs && configs.verbose) {
const isoDate = (new Date()).toISOString()
console.error(COLOR_FG_YELLOW + '[' + isoDate + '] Start mongo.execute: ' + JSON.stringify([configs, fn, args]) + COLOR_RESET)
}
const dbConfigs = util.getDeepCopiedObject(configs)
const mongoUrl = 'mongoUrl' in dbConfigs ? dbConfigs.mongoUrl : ''
const dbOption = 'dbOption' in dbConfigs ? dbConfigs.dbOption : {}
const options = 'options' in dbConfigs ? dbConfigs.options : {}
const collectionName = 'collectionName' in dbConfigs ? dbConfigs.collectionName : ''
delete dbConfigs.mongoUrl
delete dbConfigs.dbOption
delete dbConfigs.collectionName
let manager
// wrap last argument in newCallback
const callback = args[args.length - 1]
const newCallback = (error, result) => {
if ('verbose' in configs && configs.verbose) {
const isoDate = (new Date()).toISOString()
console.error(COLOR_FG_YELLOW + '[' + isoDate + '] Finish mongo.execute: ' + JSON.stringify([configs, fn, args]) + COLOR_RESET)
}
manager.close()
callback(error, result)
}
args[args.length - 1] = newCallback
manager = getCompleteManager(mongoUrl, dbOption, options, (error, manager) => {
if (error) {
return newCallback(error)
}
const collection = getCompleteCollection(manager, collectionName, dbConfigs)
try {
return collection[fn](...args)
} catch (error) {
return newCallback(error)
}
})
}
|
javascript
|
{
"resource": ""
}
|
q4692
|
train
|
function (op, other) {
return new(tree.Dimension)
(tree.operate(op, this.value, other.value),
this.unit || other.unit);
}
|
javascript
|
{
"resource": ""
}
|
|
q4693
|
getPatchedObject
|
train
|
function getPatchedObject (obj, patcher, clone = true) {
if (!patcher) {
return obj
}
let newObj, newPatcher
if (clone) {
newObj = getDeepCopiedObject(obj)
newPatcher = getDeepCopiedObject(patcher)
} else {
newObj = obj
newPatcher = patcher
}
// patch
const keys = Object.keys(newPatcher)
for (let i = 0; i < keys.length; i++) {
const key = keys[i]
if ((key in newObj) && isRealObject(newObj[key]) && isRealObject(newPatcher[key])) {
// recursive patch for if value type is newObject
try {
newObj[key] = getPatchedObject(newObj[key], newPatcher[key], false)
} catch (error) {
// do nothing, just skip
}
} else {
// simple replacement if value type is not newObject
newObj[key] = newPatcher[key]
}
}
return newObj
}
|
javascript
|
{
"resource": ""
}
|
q4694
|
visit
|
train
|
function visit(collection, pattern, address) {
collection = collection || [];
var foundSoFar = false;
collection.forEach(function (collectionItem) {
foundSoFar = foundSoFar || testForField(collectionItem, pattern, address);
});
return foundSoFar;
}
|
javascript
|
{
"resource": ""
}
|
q4695
|
resolveAddress
|
train
|
function resolveAddress(object, path) {
var parts = path.split('.');
if (object === undefined) {
return;
}
return parts.length < 2 ? object[parts[0]] : resolveAddress(object[parts[0]], parts.slice(1).join('.'));
}
|
javascript
|
{
"resource": ""
}
|
q4696
|
api
|
train
|
async function api(endpoint, token) {
token = token ? `&access_token=${token}` : '';
const response = await fetch(`https://api.github.com/repos/${endpoint}${token}`);
return response.json();
}
|
javascript
|
{
"resource": ""
}
|
q4697
|
bcadd
|
train
|
function bcadd(left_operand, right_operand, scale) {
var first, second, result;
if (typeof(scale) == 'undefined') {
scale = libbcmath.scale;
}
scale = ((scale < 0) ? 0 : scale);
// create objects
first = libbcmath.bc_init_num();
second = libbcmath.bc_init_num();
result = libbcmath.bc_init_num();
first = libbcmath.php_str2num(left_operand.toString());
second = libbcmath.php_str2num(right_operand.toString());
// normalize arguments to same scale.
if (first.n_scale > second.n_scale) second.setScale(first.n_scale);
if (second.n_scale > first.n_scale) first.setScale(second.n_scale);
result = libbcmath.bc_add(first, second, scale);
if (result.n_scale > scale) {
result.n_scale = scale;
}
return result.toString();
}
|
javascript
|
{
"resource": ""
}
|
q4698
|
bcsub
|
train
|
function bcsub(left_operand, right_operand, scale) {
var first, second, result;
if (typeof(scale) == 'undefined') {
scale = libbcmath.scale;
}
scale = ((scale < 0) ? 0 : scale);
// create objects
first = libbcmath.bc_init_num();
second = libbcmath.bc_init_num();
result = libbcmath.bc_init_num();
first = libbcmath.php_str2num(left_operand.toString());
second = libbcmath.php_str2num(right_operand.toString());
// normalize arguments to same scale.
if (first.n_scale > second.n_scale) second.setScale(first.n_scale);
if (second.n_scale > first.n_scale) first.setScale(second.n_scale);
result = libbcmath.bc_sub(first, second, scale);
if (result.n_scale > scale) {
result.n_scale = scale;
}
return result.toString();
}
|
javascript
|
{
"resource": ""
}
|
q4699
|
bccomp
|
train
|
function bccomp(left_operand, right_operand, scale) {
var first, second; //bc_num
if (typeof(scale) == 'undefined') {
scale = libbcmath.scale;
}
scale = ((scale < 0) ? 0 : scale);
first = libbcmath.bc_init_num();
second = libbcmath.bc_init_num();
first = libbcmath.bc_str2num(left_operand.toString(), scale); // note bc_ not php_str2num
second = libbcmath.bc_str2num(right_operand.toString(), scale); // note bc_ not php_str2num
return libbcmath.bc_compare(first, second, scale);
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.