_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q54100
|
train
|
function(sources){
var exists = this.sourceValues_.map(function(sourceInfo){
return sourceInfo.source;
});
var inserted = [];
var deleted = [];
var delta;
if (!sources)
sources = [];
this.sourceDelta_ = {
inserted: inserted,
deleted: deleted
};
for (var i = 0; i < sources.length; i++)
{
var source = sources[i];
if (!arrayRemove(exists, source))
this.addSource(source);
}
exists.forEach(this.removeSource, this);
this.sourceDelta_ = null;
if (delta = getDelta(inserted, deleted))
this.emit_sourcesChanged(delta);
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54101
|
values
|
train
|
function values(object){
var result = [];
for (var key in object)
result.push(object[key]);
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54102
|
slice
|
train
|
function slice(source, keys){
var result = {};
if (!keys)
return extend(result, source);
for (var i = 0, key; key = keys[i++];)
if (key in source)
result[key] = source[key];
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54103
|
splice
|
train
|
function splice(source, keys){
var result = {};
if (!keys)
return extend(result, source);
for (var i = 0, key; key = keys[i++];)
if (key in source)
{
result[key] = source[key];
delete source[key];
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54104
|
merge
|
train
|
function merge(/* obj1 .. objN */){
var result = {};
for (var i = 0; i < arguments.length; i++)
extend(result, arguments[i]);
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54105
|
iterate
|
train
|
function iterate(object, callback, thisObject){
var result = [];
for (var key in object)
result.push(callback.call(thisObject, key, object[key]));
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54106
|
factory
|
train
|
function factory(fn){
if (typeof fn != 'function')
fn = getter(fn);
var result = function(value){
return fn(value);
};
/** @cut */ result = devInfoResolver.patchFactory(result);
result.factory = FACTORY;
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54107
|
publicCallback
|
train
|
function publicCallback(fn, permanent){
var name = 'basisjsCallback' + genUID();
global[name] = permanent ? fn : function(){
try {
// IE8 and lower can't delete from global
delete global[name];
} catch(e) {
global[name] = undefined;
}
return fn.apply(this, arguments);
};
return name;
}
|
javascript
|
{
"resource": ""
}
|
q54108
|
devVerboseName
|
train
|
function devVerboseName(name, args, fn){
/** @cut */ return new Function(keys(args), 'return {"' + name + '": ' + fn + '\n}["' + name + '"]').apply(null, values(args));
/** @cut */ }
|
javascript
|
{
"resource": ""
}
|
q54109
|
train
|
function(path){
path = (path || '')
.replace(PROTOCOL_RX, '/')
.replace(ORIGIN_RX, '/') // but cut off origin
.replace(SEARCH_HASH_RX, ''); // cut off query search and hash
// use link element as path resolver
var result = [];
var parts = path.split('/'); // split
// process path parts
for (var i = 0; i < parts.length; i++)
{
if (parts[i] == '..')
{
if (result.length > 1 || result[0])
result.pop();
}
else
{
if ((parts[i] || !i) && parts[i] != '.')
result.push(parts[i]);
}
}
return result.join('/') ||
(path[0] === '/' ? '/' : '');
}
|
javascript
|
{
"resource": ""
}
|
|
q54110
|
train
|
function(path, ext){
var filename = utils.normalize(path).match(/[^\\\/]*$/);
filename = filename ? filename[0] : '';
if (ext == utils.extname(filename))
filename = filename.substring(0, filename.length - ext.length);
return filename;
}
|
javascript
|
{
"resource": ""
}
|
|
q54111
|
train
|
function(){
var args = arrayFrom(arguments).reverse();
var path = [];
var absoluteFound = false;
for (var i = 0; !absoluteFound && i < args.length; i++)
if (typeof args[i] == 'string')
{
path.unshift(args[i]);
absoluteFound = ABSOLUTE_RX.test(args[i]);
}
if (!absoluteFound)
path.unshift(baseURI == '/' ? '' : baseURI);
else if (path.length && path[0] == '/')
path[0] = '';
return utils.normalize(path.join('/'));
}
|
javascript
|
{
"resource": ""
}
|
|
q54112
|
train
|
function(from, to){
// it makes function useful with array iterate methods, i.e.
// ['foo', 'bar'].map(basis.path.relative)
if (typeof to != 'string')
{
to = from;
from = baseURI;
}
from = utils.normalize(from);
to = utils.normalize(to);
if (from[0] == '/' && to[0] != '/')
return from;
if (to[0] == '/' && from[0] != '/')
return to;
var base = from.replace(/^\/$/, '').split(/\//);
var path = to.replace(/^\/$/, '').split(/\//);
var result = [];
var i = 0;
while (path[i] == base[i] && typeof base[i] == 'string')
i++;
for (var j = base.length - i; j > 0; j--)
result.push('..');
return result.concat(path.slice(i).filter(Boolean)).join('/');
}
|
javascript
|
{
"resource": ""
}
|
|
q54113
|
fetchConfig
|
train
|
function fetchConfig(){
var config = __config;
if (!config)
{
if (NODE_ENV)
{
// node.js env
basisFilename = process.basisjsFilename || __filename.replace(/\\/g, '/');
/** @cut */ if (process.basisjsConfig)
/** @cut */ {
/** @cut */ config = process.basisjsConfig;
/** @cut */ if (typeof config == 'string')
/** @cut */ {
/** @cut */ try {
/** @cut */ config = Function('return{' + config + '}')();
/** @cut */ } catch(e) {
/** @cut */ /** @cut */ consoleMethods.error('basis-config: basis.js config parse fault: ' + e);
/** @cut */ }
/** @cut */ }
/** @cut */ }
}
else
{
// browser env
var scripts = document.scripts;
for (var i = 0, scriptEl; scriptEl = scripts[i]; i++)
{
var configAttrValue = scriptEl.hasAttribute('basis-config')
? scriptEl.getAttribute('basis-config')
: scriptEl.getAttribute('data-basis-config');
scriptEl.removeAttribute('basis-config');
scriptEl.removeAttribute('data-basis-config');
if (configAttrValue !== null)
{
basisFilename = pathUtils.normalize(scriptEl.src);
try {
config = Function('return{' + configAttrValue + '}')();
} catch(e) {
/** @cut */ consoleMethods.error('basis-config: basis.js config parse fault: ' + e);
}
break;
}
}
if (!basisFilename)
{
basisFilename = pathUtils.normalize(scripts[0].src);
/** @cut */ consoleMethods.warn('basis-config: no `basis-config` marker on any script tag is found. All paths will be resolved relative to `src` from the first `script` tag.');
}
}
}
return processConfig(config);
}
|
javascript
|
{
"resource": ""
}
|
q54114
|
processConfig
|
train
|
function processConfig(config){
// make a copy of config
config = slice(config);
// extend by default settings
complete(config, {
implicitExt: NODE_ENV ? true : false // true, false, 'warn'
});
// warn about extProto in basis-config, this option was removed in 1.3.0
/** @cut */ if ('extProto' in config)
/** @cut */ consoleMethods.warn('basis-config: `extProto` option in basis-config is not support anymore');
// warn about path in basis-config, this option was deprecated in 1.3.0
/** @cut */ if ('path' in config)
/** @cut */ consoleMethods.warn('basis-config: `path` option in basis-config is deprecated, use `modules` instead');
// build modules list
var autoload = [];
var modules = merge(config.path, config.modules, {
basis: basisFilename
});
// reset modules
config.modules = {};
// process autoload
if (config.autoload)
{
// [path/to/][name][.rest.ext] -> {
// name: name,
// filename: path + name + rest
// }
var m = String(config.autoload).match(/^((?:[^\/]*\/)*)([a-z$_][a-z0-9$_]*)((?:\.[a-z$_][a-z0-9$_]*)*)$/i);
if (m)
{
modules[m[2]] = {
autoload: true,
filename: m[1] + m[2] + (m[3] || '.js')
};
}
else
{
/** @cut */ consoleMethods.warn('basis-config: wrong `autoload` value (setting ignored): ' + config.autoload);
}
delete config.autoload;
}
// process modules
for (var name in modules)
{
// name: {
// autoload: boolean,
// path: 'path/to',
// filename: 'module.js'
// }
//
// or
//
// name: 'filename'
var module = modules[name];
// if value is string, convert to config
if (typeof module == 'string')
// value is filename
module = {
// if path ends with `/` add `[name].js` to the end
filename: module.replace(/\/$/, '/' + name + '.js')
};
// get and resolve path and filename
var filename = module.filename;
var path = module.path;
// if no path but filename
// let filename equals to 'path/to/file[.ext]', then
// path = 'path/to/file'
// filename = '../file[.ext]'
if (filename && !path)
{
filename = pathUtils.resolve(filename);
path = filename.substr(0, filename.length - pathUtils.extname(filename).length);
filename = '../' + pathUtils.basename(filename);
}
// path should be absolute
// at this point path is defined in any case
path = pathUtils.resolve(path);
// if no filename but path
// let path equals to 'path/to/file[.ext]', then
// path = 'path/to'
// filename = 'file[.ext]'
if (!filename && path)
{
filename = pathUtils.basename(path);
path = pathUtils.dirname(path);
}
// if filename has no extension, adds `.js`
if (!pathUtils.extname(filename))
filename += '.js';
// resolve filename
filename = pathUtils.resolve(path, filename);
// store results
config.modules[name] = {
path: path,
filename: filename
};
// store autoload modules
if (module.autoload)
{
config.autoload = autoload;
autoload.push(name);
}
}
return config;
}
|
javascript
|
{
"resource": ""
}
|
q54115
|
createClass
|
train
|
function createClass(SuperClass){
var classId = classSeed++;
if (typeof SuperClass != 'function')
SuperClass = BaseClass;
/** @cut */ var className = '';
/** @cut */ for (var i = 1, extension; extension = arguments[i]; i++)
/** @cut */ if (typeof extension != 'function' && extension.className)
/** @cut */ className = extension.className;
/** @cut */ if (!className)
/** @cut */ className = SuperClass.className + '._Class' + classId;
// temp class constructor with no init call
var NewClassProto = function(){};
// verbose name in dev
/** @cut */ NewClassProto = devVerboseName(className, {}, NewClassProto);
NewClassProto.prototype = SuperClass.prototype;
var newProto = new NewClassProto;
var newClassProps = {
/** @cut */ className: className,
basisClassId_: classId,
superClass_: SuperClass,
extendConstructor_: !!SuperClass.extendConstructor_,
// class methods
isSubclassOf: isSubclassOf,
subclass: function(){
return createClass.apply(null, [NewClass].concat(arrayFrom(arguments)));
},
extend: extendClass,
factory: function(config){
return factory(function(extra){
return new NewClass(merge(config, extra));
});
},
// auto extend creates a subclass
__extend__: function(value){
if (value && value !== SELF && (typeof value == 'object' || (typeof value == 'function' && !isClass(value))))
return BaseClass.create.call(null, NewClass, value);
else
return value;
},
// new class prototype
prototype: newProto
};
// extend NewClass prototype
for (var i = 1, extension; extension = arguments[i]; i++)
newClassProps.extend(extension);
/** @cut */if (newProto.init !== BaseClass.prototype.init && !/^function[^(]*\(\)/.test(newProto.init) && newClassProps.extendConstructor_) consoleMethods.warn('probably wrong extendConstructor_ value for ' + newClassProps.className);
// new class constructor
var NewClass = newClassProps.extendConstructor_
// constructor with instance extension
? function(extend){
// mark object
this.basisObjectId = instanceSeed.id++;
// extend and override instance properties
var prop;
for (var key in extend)
{
prop = this[key];
this[key] = prop && prop.__extend__
? prop.__extend__(extend[key])
: extend[key];
}
// call constructor
this.init();
// post init
this.postInit();
}
// simple constructor
: function(){
// mark object
this.basisObjectId = instanceSeed.id++;
// call constructor
this.init.apply(this, arguments);
// post init
this.postInit();
};
// verbose name in dev
// NOTE: this code makes Chrome and Firefox show class name in console
/** @cut */ NewClass = devVerboseName(className, { instanceSeed: instanceSeed }, NewClass);
// add constructor property to prototype
newProto.constructor = NewClass;
for (var key in newProto)
if (newProto[key] === SELF)
newProto[key] = NewClass;
//else
// newProto[key] = newProto[key];
// extend constructor with properties
extend(NewClass, newClassProps);
// for class introspection
/** @cut */ classes.push(NewClass);
// return new class
return NewClass;
}
|
javascript
|
{
"resource": ""
}
|
q54116
|
train
|
function(value){
if (value && value !== SELF && (typeof value == 'object' || (typeof value == 'function' && !isClass(value))))
return BaseClass.create.call(null, NewClass, value);
else
return value;
}
|
javascript
|
{
"resource": ""
}
|
|
q54117
|
extendClass
|
train
|
function extendClass(source){
var proto = this.prototype;
if (typeof source == 'function' && !isClass(source))
source = source(this.superClass_.prototype, slice(proto));
if (source.prototype)
source = source.prototype;
for (var key in source)
{
var value = source[key];
var protoValue = proto[key];
if (key == 'className' || key == 'extendConstructor_')
this[key] = value;
else
{
if (protoValue && protoValue.__extend__)
proto[key] = protoValue.__extend__(value);
else
{
proto[key] = value;
///** @cut */ if (value && !value.__extend__ && (value.constructor == Object || value.constructor == Array)){ consoleMethods.warn('!' + key); }
}
}
}
// for browsers that doesn't enum toString
if (TOSTRING_BUG && source[key = 'toString'] !== toString)
proto[key] = source[key];
return this;
}
|
javascript
|
{
"resource": ""
}
|
q54118
|
train
|
function(){
var value = this.get();
var cursor = this;
while (cursor = cursor.handler)
cursor.fn.call(cursor.context, value);
}
|
javascript
|
{
"resource": ""
}
|
|
q54119
|
train
|
function(){
var token = this.deferredToken;
if (!token)
{
token = this.deferredToken = new DeferredToken(this.get());
this.attach(token.set, token);
}
return token;
}
|
javascript
|
{
"resource": ""
}
|
|
q54120
|
train
|
function(fn){
var token = new Token();
var setter = function(value){
this.set(fn.call(this, value));
};
if (typeof fn != 'function')
fn = getter(fn);
setter.call(token, this.get());
this.attach(setter, token, token.destroy);
token.attach($undef, this, function(){
this.detach(setter, token);
});
/** @cut */ devInfoResolver.setInfo(token, 'sourceInfo', {
/** @cut */ type: 'Token#as',
/** @cut */ source: this,
/** @cut */ transform: fn
/** @cut */ });
return token;
}
|
javascript
|
{
"resource": ""
}
|
|
q54121
|
train
|
function(){
if (this.deferredToken)
{
this.deferredToken.destroy();
this.deferredToken = null;
}
this.attach = $undef;
this.detach = $undef;
var cursor = this;
while (cursor = cursor.handler)
if (cursor.destroy)
cursor.destroy.call(cursor.context);
this.handler = null;
this.value = null;
}
|
javascript
|
{
"resource": ""
}
|
|
q54122
|
train
|
function(searchElement, offset){
offset = parseInt(offset, 10) || 0;
if (offset < 0)
return -1;
for (; offset < this.length; offset++)
if (this[offset] === searchElement)
return offset;
return -1;
}
|
javascript
|
{
"resource": ""
}
|
|
q54123
|
train
|
function(callback, initialValue){
var len = this.length;
var argsLen = arguments.length;
// no value to return if no initial value and an empty array
if (len == 0 && argsLen == 1)
throw new TypeError();
var result;
var inited = 0;
if (argsLen > 1)
{
result = initialValue;
inited = 1;
}
for (var i = 0; i < len; i++)
if (i in this)
if (inited++)
result = callback.call(null, result, this[i], i, this);
else
result = this[i];
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q54124
|
train
|
function(){
return {
bindDragNDrop: function(node, handlers){
if (handlers)
{
var events = Viva.Graph.Utils.dragndrop(node.ui.element);
['onStart', 'onDrag', 'onStop'].forEach(function(name){
if (typeof handlers[name] === 'function')
events[name](handlers[name]);
});
node.events = events;
}
else if (node.events)
{ // TODO: i'm not sure if this is required in JS world...
node.events.release();
node.events = null;
}
}
};
}
|
javascript
|
{
"resource": ""
}
|
|
q54125
|
train
|
function(rule){
rule = basis.getter(rule || $true);
if (this.rule !== rule)
{
var oldRule = this.rule;
this.rule = rule;
this.emit_ruleChanged(oldRule);
/** @cut */ basis.dev.patchInfo(this, 'sourceInfo', {
/** @cut */ transform: this.rule
/** @cut */ });
return this.applyRule();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54126
|
train
|
function(){
var sourceMap = this.sourceMap_;
var memberMap = this.members_;
var curMember;
var newMember;
var curMemberId;
var newMemberId;
var sourceObject;
var sourceObjectInfo;
var inserted = [];
var deleted = [];
var delta;
for (var sourceObjectId in sourceMap)
{
sourceObjectInfo = sourceMap[sourceObjectId];
sourceObject = sourceObjectInfo.sourceObject;
curMember = sourceObjectInfo.member;
newMember = this.map ? this.map(sourceObject) : sourceObject;
if (newMember instanceof DataObject == false || this.filter(newMember))
newMember = null;
if (!isEqual(curMember, newMember))
{
sourceObjectInfo.member = newMember;
// if here is ref for member already
if (curMember)
{
curMemberId = curMember.basisObjectId;
// call callback on member ref add
if (this.removeMemberRef)
this.removeMemberRef(curMember, sourceObject);
// decrease ref count
memberMap[curMemberId]--;
}
// if new member exists, update map
if (newMember)
{
newMemberId = newMember.basisObjectId;
// call callback on member ref add
if (this.addMemberRef)
this.addMemberRef(newMember, sourceObject);
if (newMemberId in memberMap)
{
// member is already in map -> increase ref count
memberMap[newMemberId]++;
}
else
{
// add to map
memberMap[newMemberId] = 1;
// add to delta
inserted.push(newMember);
}
}
}
}
// get deleted delta
for (curMemberId in this.items_)
if (memberMap[curMemberId] == 0)
{
delete memberMap[curMemberId];
deleted.push(this.items_[curMemberId]);
}
// if any changes, fire event
if (delta = getDelta(inserted, deleted))
this.emit_itemsChanged(delta);
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54127
|
train
|
function(offset, limit){
var oldOffset = this.offset;
var oldLimit = this.limit;
var delta = false;
if (oldOffset != offset || oldLimit != limit)
{
this.offset = offset;
this.limit = limit;
delta = this.applyRule();
this.emit_rangeChanged(oldOffset, oldLimit);
}
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54128
|
train
|
function(rule, orderDesc){
rule = basis.getter(rule || $true);
orderDesc = !!orderDesc;
if (this.rule != rule || this.orderDesc != orderDesc)
{
var oldRule = this.rule;
var oldOrderDesc = this.orderDesc;
// rebuild index only if rule changing
if (this.rule != rule)
{
var index = this.index_;
for (var i = 0; i < index.length; i++)
index[i].value = nanToUndefined(rule(index[i].object));
index.sort(sliceIndexSort);
this.rule = rule;
}
// set new values
this.orderDesc = orderDesc;
this.rule = rule;
this.emit_ruleChanged(oldRule, oldOrderDesc);
return this.applyRule();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54129
|
train
|
function(){
var start = this.offset;
var end = start + this.limit;
if (this.orderDesc)
{
start = this.index_.length - end;
end = start + this.limit;
}
var curSet = objectSlice(this.members_);
var newSet = this.index_.slice(Math.max(0, start), Math.max(0, end));
var inserted = [];
var delta;
for (var i = 0, item; item = newSet[i]; i++)
{
var objectId = item.object.basisObjectId;
if (curSet[objectId])
delete curSet[objectId];
else
{
inserted.push(item.object);
this.members_[objectId] = item.object;
}
}
for (var objectId in curSet)
delete this.members_[objectId];
// update left tokens
if (this.left_)
for (var offset in this.left_)
{
var item = this.index_[this.orderDesc ? end + Number(offset) - 1 : start - Number(offset)];
this.left_[offset].set(item ? item.object : null);
}
// update right tokens
if (this.right_)
for (var offset in this.right_)
{
var item = this.index_[this.orderDesc ? start - Number(offset) : end + Number(offset) - 1];
this.right_[offset].set(item ? item.object : null);
}
// emit event if any delta
if (delta = getDelta(inserted, values(curSet)))
this.emit_itemsChanged(delta);
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54130
|
train
|
function(){
// this -> {
// owner: owner,
// name: satelliteName,
// config: satelliteConfig,
// instance: satelliteInstance or null,
// instanceRA_: ResolveAdapter or null,
// existsRA_: ResolveAdapter or null
// factoryType: 'value' or 'class'
// factory: class or any
// }
var name = this.name;
var config = this.config;
var owner = this.owner;
var exists = ('existsIf' in config == false) || config.existsIf(owner);
if (resolveValue(this, SATELLITE_UPDATE, exists, 'existsRA_'))
{
var satellite = this.instance || config.instance;
if (!satellite || this.factoryType == 'value')
{
if (!this.factoryType)
{
var instanceValue = config.getInstance;
var instanceClass = config.instanceClass;
if (typeof instanceValue == 'function')
{
instanceValue = instanceValue.call(owner, owner);
if (Class.isClass(instanceValue))
instanceClass = processInstanceClass(instanceValue);
}
this.factoryType = instanceClass ? 'class' : 'value';
this.factory = instanceClass || instanceValue;
}
if (this.factoryType == 'class')
{
var satelliteConfig = {
destroy: warnOnAutoSatelliteDestoy // auto-create satellite marker, lock destroy method invocation
};
if (config.delegate)
{
satelliteConfig.autoDelegate = false;
satelliteConfig.delegate = config.delegate(owner);
}
if (config.dataSource)
satelliteConfig.dataSource = config.dataSource(owner);
if (config.config)
basis.object.complete(satelliteConfig, typeof config.config == 'function'
? config.config(owner)
: config.config
);
this.instance = new this.factory(satelliteConfig);
owner.setSatellite(name, this.instance, true);
/** @cut */ var loc = basis.dev.getInfo(config, 'loc');
/** @cut */ if (loc)
/** @cut */ basis.dev.setInfo(this.instance, 'loc', loc);
return;
}
// factoryType == 'value'
satellite = resolveAbstractNode(this, SATELLITE_UPDATE, this.factory, 'instanceRA_');
}
if (this.instance !== satellite)
{
this.instance = satellite || null;
owner.setSatellite(name, this.instance, true);
}
if (satellite && satellite.owner === owner)
{
if (config.delegate)
satellite.setDelegate(config.delegate(owner));
if (config.dataSource)
satellite.setDataSource(config.dataSource(owner));
}
}
else
{
var satellite = this.instance;
if (satellite)
{
if (config.instance)
{
if (config.delegate)
satellite.setDelegate();
if (config.dataSource)
satellite.setDataSource();
}
this.instance = null;
owner.setSatellite(name, null, true);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54131
|
train
|
function(name, satellite, autoSet){
var oldSatellite = this.satellite[name] || null;
var auto = this.satellite[AUTO];
var autoConfig = auto && auto[name];
var preserveAuto = autoSet && autoConfig;
if (preserveAuto)
{
satellite = autoConfig.instance;
if (satellite && autoConfig.config.instance)
delete autoConfig.config.instance.setOwner;
}
else
{
satellite = processSatelliteConfig(satellite);
if (satellite && satellite.owner === this && auto && satellite.ownerSatelliteName && auto[satellite.ownerSatelliteName])
{
/** @cut */ basis.dev.warn(namespace + ': auto-create satellite can\'t change name inside owner');
return;
}
// if setSatellite was called not on auto-satellite update
if (autoConfig)
{
// remove old auto-config
delete auto[name];
if (autoConfig.config.instance)
autoConfig.config.instance.removeHandler(AUTO_SATELLITE_INSTANCE_HANDLER, autoConfig);
if (autoConfig.config.handler)
this.removeHandler(autoConfig.config.handler, autoConfig);
}
}
if (oldSatellite !== satellite)
{
var satelliteListen = this.listen.satellite;
var satellitePersonalListen = this.listen['satellite:' + name];
var destroySatellite;
if (oldSatellite)
{
// unlink old satellite
delete this.satellite[name];
var oldSatelliteName = oldSatellite.ownerSatelliteName;
if (oldSatelliteName != null)
{
oldSatellite.ownerSatelliteName = null;
oldSatellite.emit_ownerSatelliteNameChanged(oldSatelliteName);
}
if (autoConfig && oldSatellite.destroy === warnOnAutoSatelliteDestoy)
{
destroySatellite = oldSatellite;
}
else
{
// regular satellite
if (satelliteListen)
oldSatellite.removeHandler(satelliteListen, this);
if (satellitePersonalListen)
oldSatellite.removeHandler(satellitePersonalListen, this);
oldSatellite.setOwner(null);
}
if (preserveAuto && !satellite && autoConfig.config.instance)
autoConfig.config.instance.setOwner = warnOnAutoSatelliteOwnerChange;
}
if (satellite)
{
// check value is auto-config
if (satellite instanceof AbstractNode == false)
{
// auto-create satellite
var autoConfig = {
owner: this,
name: name,
config: satellite,
factoryType: null,
factory: null,
instance: null,
instanceRA_: null,
existsRA_: null
};
// auto-create satellite
if (satellite.handler)
this.addHandler(satellite.handler, autoConfig);
if (satellite.instance)
{
satellite.instance.addHandler(AUTO_SATELLITE_INSTANCE_HANDLER, autoConfig);
satellite.instance.setOwner = warnOnAutoSatelliteOwnerChange;
}
// create auto
if (!auto)
{
if (this.satellite === NULL_SATELLITE)
this.satellite = {};
auto = this.satellite[AUTO] = {};
}
auto[name] = autoConfig;
SATELLITE_UPDATE.call(autoConfig, this);
if (!autoConfig.instance && oldSatellite)
this.emit_satelliteChanged(name, oldSatellite);
if (destroySatellite)
{
// auto create satellite must be destroyed
delete destroySatellite.destroy;
destroySatellite.destroy();
}
return;
}
// link new satellite
if (satellite.owner !== this)
{
if (autoConfig && autoConfig.config.delegate)
{
// ignore autoDelegate if satellite is auto-satellite and config has delegate setting
var autoDelegate = satellite.autoDelegate;
satellite.autoDelegate = false;
satellite.setOwner(this);
satellite.autoDelegate = autoDelegate;
}
else
satellite.setOwner(this);
// reset satellite if owner was not set
if (satellite.owner !== this)
{
this.setSatellite(name, null);
return;
}
if (satelliteListen)
satellite.addHandler(satelliteListen, this);
if (satellitePersonalListen)
satellite.addHandler(satellitePersonalListen, this);
}
else
{
// move satellite inside owner
if (satellite.ownerSatelliteName)
{
delete this.satellite[satellite.ownerSatelliteName];
this.emit_satelliteChanged(satellite.ownerSatelliteName, satellite);
}
}
if (this.satellite == NULL_SATELLITE)
this.satellite = {};
this.satellite[name] = satellite;
var oldSatelliteName = satellite.ownerSatelliteName;
if (oldSatelliteName != name)
{
satellite.ownerSatelliteName = name;
satellite.emit_ownerSatelliteNameChanged(oldSatelliteName);
}
}
this.emit_satelliteChanged(name, oldSatellite);
if (destroySatellite)
{
// auto create satellite must be destroyed
delete destroySatellite.destroy;
destroySatellite.destroy();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54132
|
train
|
function(newNode, refNode){
var nodes = this.nodes;
var pos = refNode ? nodes.indexOf(refNode) : -1;
if (pos == -1)
{
nodes.push(newNode);
this.last = newNode;
}
else
nodes.splice(pos, 0, newNode);
this.first = nodes[0];
newNode.groupNode = this;
this.emit_childNodesModified({ inserted: [newNode] });
}
|
javascript
|
{
"resource": ""
}
|
|
q54133
|
train
|
function(oldNode){
var nodes = this.nodes;
if (arrayRemove(nodes, oldNode))
{
this.first = nodes[0] || null;
this.last = nodes[nodes.length - 1] || null;
oldNode.groupNode = null;
this.emit_childNodesModified({ deleted: [oldNode] });
}
if (!this.first && this.autoDestroyIfEmpty)
this.destroy();
}
|
javascript
|
{
"resource": ""
}
|
|
q54134
|
train
|
function(matchFunction){
if (this.matchFunction != matchFunction)
{
var oldMatchFunction = this.matchFunction;
this.matchFunction = matchFunction;
for (var node = this.lastChild; node; node = node.previousSibling)
node.match(matchFunction);
this.emit_matchFunctionChanged(oldMatchFunction);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54135
|
train
|
function(selection, silent){
var oldSelection = this.selection;
if (selection instanceof Selection === false)
selection = selection ? new Selection(selection) : null;
if (oldSelection !== selection)
{
// change context selection for child nodes
updateNodeContextSelection(this, oldSelection || this.contextSelection, selection || this.contextSelection, false, true);
if (this.listen.selection)
{
if (oldSelection)
oldSelection.removeHandler(this.listen.selection, this);
if (selection)
selection.addHandler(this.listen.selection, this);
}
// update selection
this.selection = selection;
if (!silent)
this.emit_selectionChanged(oldSelection);
return true;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54136
|
train
|
function(selected, multiple){
var selection = this.contextSelection;
selected = !!resolveValue(this, this.setSelected, selected, 'selectedRA_');
// special case, when node selected and has selection context check only
// resolve adapter influence on selected if exists, and restore selection
// influence when no resolve adapter
if (this.selected && selection)
{
if (this.selectedRA_)
{
if (selection.has(this))
{
this.selected = false;
selection.remove(this);
this.selected = true;
}
}
else
{
if (!selection.has(this))
selection.add(this);
}
}
if (selected !== this.selected)
{
if (this.selectedRA_) // when resolveValue using ignore selection
{
this.selected = selected;
if (selected)
this.emit_select();
else
this.emit_unselect();
}
else
{
if (selected) // this.selected = false -> true
{
if (selection)
{
if (multiple)
selection.add(this);
else
selection.set(this);
}
else
{
this.selected = true;
this.emit_select();
}
}
else // this.selected = true -> false
{
if (selection)
{
selection.remove(this);
}
else
{
this.selected = false;
this.emit_unselect();
}
}
}
return true;
}
else
{
if (!this.selectedRA_ && selected && selection) // this.selected = true -> true
{
if (multiple)
selection.remove(this);
else
selection.set(this);
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q54137
|
train
|
function(disabled){
disabled = !!resolveValue(this, this.setDisabled, disabled, 'disabledRA_');
if (this.disabled !== disabled)
{
this.disabled = disabled;
if (!this.contextDisabled)
if (disabled)
this.emit_disable();
else
this.emit_enable();
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q54138
|
train
|
function(isActive){
var proxyToken = this.activeRA_ && this.activeRA_.proxyToken;
if (isActive === PROXY)
{
if (!proxyToken)
{
proxyToken = new basis.Token(this.subscriberCount > 0);
this.addHandler(ABSTRACTDATA_ACTIVE_SYNC_HANDLER, proxyToken);
}
isActive = proxyToken;
}
else
{
if (proxyToken && isActive !== proxyToken)
{
this.removeHandler(ABSTRACTDATA_ACTIVE_SYNC_HANDLER, proxyToken);
proxyToken = null;
}
}
isActive = !!resolveValue(this, this.setActive, isActive, 'activeRA_');
if (proxyToken && this.activeRA_)
this.activeRA_.proxyToken = proxyToken;
if (this.active != isActive)
{
this.active = isActive;
this.emit_activeChanged();
if (isActive)
SUBSCRIPTION.subscribe(this, this.subscribeTo);
else
SUBSCRIPTION.unsubscribe(this, this.subscribeTo);
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q54139
|
train
|
function(subscriptionType){
var curSubscriptionType = this.subscribeTo;
var newSubscriptionType = subscriptionType & SUBSCRIPTION.ALL;
var delta = curSubscriptionType ^ newSubscriptionType;
if (delta)
{
this.subscribeTo = newSubscriptionType;
if (this.active)
SUBSCRIPTION.changeSubscription(this, curSubscriptionType, newSubscriptionType);
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q54140
|
train
|
function(syncAction){
var oldAction = this.syncAction;
if (typeof syncAction != 'function')
syncAction = null;
this.syncAction = syncAction;
if (syncAction)
{
if (!oldAction)
this.addHandler(this.syncEvents);
if (this.isSyncRequired())
callSyncAction(this);
}
else
{
if (oldAction)
this.removeHandler(this.syncEvents);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54141
|
createResolveFunction
|
train
|
function createResolveFunction(Class){
return function resolve(context, fn, source, property, factoryContext){
var oldAdapter = context[property] || null;
var newAdapter = null;
if (fn !== resolveAdapterProxy && typeof source == 'function')
source = source.call(factoryContext || context, factoryContext || context);
if (source && source.bindingBridge)
{
if (!oldAdapter || oldAdapter.source !== source)
newAdapter = new BBResolveAdapter(context, fn, source, DEFAULT_CHANGE_ADAPTER_HANDLER);
else
newAdapter = oldAdapter;
source = resolve(newAdapter, resolveAdapterProxy, source.bindingBridge.get(source), 'next');
}
if (source instanceof Class == false)
source = null;
if (property && oldAdapter !== newAdapter)
{
var cursor = oldAdapter;
// drop old adapter chain
while (cursor)
{
var adapter = cursor;
adapter.detach();
cursor = adapter.next;
adapter.next = null;
}
if (newAdapter)
newAdapter.attach(DEFAULT_DESTROY_ADAPTER_HANDLER);
context[property] = newAdapter;
}
return source;
};
}
|
javascript
|
{
"resource": ""
}
|
q54142
|
resolveValue
|
train
|
function resolveValue(context, fn, source, property, factoryContext){
var oldAdapter = context[property] || null;
var newAdapter = null;
// as functions could be a value, invoke only functions with factory property
// i.e. source -> function(){ /* factory code */ }).factory === FACTORY
// apply only for top-level resolveValue() invocation
if (source && fn !== resolveAdapterProxy && basis.fn.isFactory(source))
source = source.call(factoryContext || context, factoryContext || context);
if (source && source.bindingBridge)
{
if (!oldAdapter || oldAdapter.source !== source)
newAdapter = new BBResolveAdapter(context, fn, source, DEFAULT_CHANGE_ADAPTER_HANDLER);
else
newAdapter = oldAdapter;
source = resolveValue(newAdapter, resolveAdapterProxy, source.bindingBridge.get(source), 'next');
}
if (property && oldAdapter !== newAdapter)
{
var cursor = oldAdapter;
// drop old adapter chain
while (cursor)
{
var adapter = cursor;
adapter.detach();
cursor = adapter.next;
adapter.next = null;
}
if (newAdapter)
newAdapter.attach(RESOLVEVALUE_DESTROY_ADAPTER_HANDLER);
context[property] = newAdapter;
}
return source;
}
|
javascript
|
{
"resource": ""
}
|
q54143
|
train
|
function(){
var insertedMap = {};
var deletedMap = {};
var delta;
for (var key in this.sourceMap_)
{
var sourceObjectInfo = this.sourceMap_[key];
var sourceObject = sourceObjectInfo.source;
if (sourceObject instanceof DataObject)
{
var newValue = this.rule(sourceObject) || null;
var oldValue = sourceObjectInfo.value;
if (isEqual(newValue, oldValue))
continue;
if (newValue instanceof DataObject || newValue instanceof ReadOnlyDataset)
{
var inserted = addToExtract(this, newValue, sourceObject);
for (var i = 0; i < inserted.length; i++)
{
var item = inserted[i];
var id = item.basisObjectId;
if (deletedMap[id])
delete deletedMap[id];
else
insertedMap[id] = item;
}
}
if (oldValue)
{
var deleted = removeFromExtract(this, oldValue, sourceObject);
for (var i = 0; i < deleted.length; i++)
{
var item = deleted[i];
var id = item.basisObjectId;
if (insertedMap[id])
delete insertedMap[id];
else
deletedMap[id] = item;
}
}
// update value
sourceObjectInfo.value = newValue;
}
}
if (delta = getDelta(values(insertedMap), values(deletedMap)))
this.emit_itemsChanged(delta);
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54144
|
createAction
|
train
|
function createAction(config){
// make a copy of config with defaults
config = basis.object.extend({
prepare: nothingToDo,
request: nothingToDo
}, config);
// if body is function take in account special action context
if (typeof config.body == 'function')
{
var bodyFn = config.body;
config.body = function(){
return bodyFn.apply(this.context, this.args);
};
}
// splice properties
var fn = basis.object.splice(config, ['prepare', 'request']);
var callback = basis.object.merge(
DEFAULT_CALLBACK,
basis.object.splice(config, ['start', 'success', 'failure', 'abort', 'complete'])
);
// lazy transport
var getTransport = basis.fn.lazyInit(function(){
var transport = resolveTransport(config);
transport.addHandler(CALLBACK_HANDLER, callback);
return transport;
});
return function action(){
// this - instance of AbstractData
if (this.state != STATE_PROCESSING)
{
if (fn.prepare.apply(this, arguments))
{
/** @cut */ basis.dev.info('Prepare handler returns trulthy result. Operation aborted. Context: ', this);
return Promise.reject('Prepare handler returns trulthy result. Operation aborted. Context: ', this);
}
var request;
var requestData = basis.object.complete({
origin: this,
bodyContext: {
context: this,
args: basis.array(arguments)
}
}, fn.request.apply(this, arguments));
// if body is function take in account special action context
if (typeof requestData.body == 'function')
{
var bodyFn = requestData.body;
requestData.body = function(){
return bodyFn.apply(this.context, this.args);
};
}
// do a request
if (request = getTransport().request(requestData))
return new Promise(function(fulfill, reject){
request.addHandler(PROMISE_REQUEST_HANDLER, {
request: request,
fulfill: fulfill,
reject: reject
});
});
return Promise.reject('Request is not performed');
}
else
{
/** @cut */ basis.dev.warn('Context in processing state. Operation aborted. Context: ', this);
return Promise.reject('Context in processing state, request is not performed');
}
};
}
|
javascript
|
{
"resource": ""
}
|
q54145
|
train
|
function(){
// set up router
router.route(/^\/(active|completed)$/).param(0).as(function(subset){
Todo.selected.set(Todo[subset || 'all']);
});
// return app root node
return new Node({
template: resource('./app/template/layout.tmpl'),
binding: {
// nested views
form: resource('./module/form/index.js'),
list: resource('./module/list/index.js'),
stat: resource('./module/stat/index.js')
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q54146
|
legacyAttrClass
|
train
|
function legacyAttrClass(domRef, oldClass, newValue, anim){
var newClass = newValue || '';
if (newClass != oldClass)
{
var className = domRef.className;
var classNameIsObject = typeof className != 'string';
var classList;
if (classNameIsObject)
className = className.baseVal;
classList = className.split(WHITESPACE);
if (oldClass)
basis.array.remove(classList, oldClass);
if (newClass)
{
classList.push(newClass);
if (anim)
{
basis.array.add(classList, newClass + '-anim');
basis.nextTick(function(){
var classList = (classNameIsObject ? domRef.className.baseVal : domRef.className).split(WHITESPACE);
basis.array.remove(classList, newClass + '-anim');
if (classNameIsObject)
domRef.className.baseVal = classList.join(' ');
else
domRef.className = classList.join(' ');
});
}
}
if (classNameIsObject)
domRef.className.baseVal = classList.join(' ');
else
domRef.className = classList.join(' ');
}
return newClass;
}
|
javascript
|
{
"resource": ""
}
|
q54147
|
setRequestHeaders
|
train
|
function setRequestHeaders(xhr, requestData){
var headers = {};
if (IS_METHOD_WITH_BODY.test(requestData.method))
{
// when send a FormData instance, browsers serialize it and
// set correct content-type header with boundary
if (!FormData || requestData.body instanceof FormData == false)
headers['Content-Type'] = requestData.contentType + (requestData.encoding ? '\x3Bcharset=' + requestData.encoding : '');
}
else
{
if (ua.test('ie')) // disable IE caching
{
// new Date(0).toGMTString() is not correct here;
// IE returns date string with no leading zero and IIS may parse
// date wrong and response with code 400
headers['If-Modified-Since'] = 'Thu, 01 Jan 1970 00:00:00 GMT';
}
}
headers = basis.object.merge(headers, requestData.headers);
objectIterate(requestData.headers, function(name, value){
if (name.trim().toLowerCase() == 'content-type')
{
/** @cut */ basis.dev.warn('basis.net.ajax: `Content-Type` header found in request data, use contentType and encoding properties instead');
headers['Content-Type'] = value;
}
else
headers[name] = value;
});
objectIterate(headers, function(key, value){
if (value != null && typeof value != 'function')
xhr.setRequestHeader(key, value);
else
delete headers[key];
});
return headers;
}
|
javascript
|
{
"resource": ""
}
|
q54148
|
XML2Object
|
train
|
function XML2Object(node, mapping){ // require for refactoring
var nodeType = node.nodeType;
var attributes = node.attributes;
var firstChild = node.firstChild;
if (!firstChild)
{
var firstAttr = attributes && attributes[0];
if (nodeType == ELEMENT_NODE)
{
if (!firstAttr)
return '';
// test for <node xsi:nil="true"/>
if (attributes.length == 1 &&
(firstAttr.baseName || firstAttr.localName) == XSI_NIL_LOCALPART &&
firstAttr.namespaceURI == XSI_NAMESPACE)
return null;
}
else
{
if (!firstAttr)
return null;
}
}
else
{
// single child node and not an element -> return child nodeValue
if (firstChild.nodeType != ELEMENT_NODE && firstChild === node.lastChild)
return firstChild.nodeValue;
else
if (firstChild !== node.lastChild && firstChild.nodeType == TEXT_NODE)
{
var isSeparatedTextNode = true;
var result = '';
var cursor = firstChild;
do
{
if (cursor.nodeType !== TEXT_NODE)
{
isSeparatedTextNode = false;
break;
}
result += cursor.nodeValue;
}
while (cursor = cursor.nextSibling);
if (isSeparatedTextNode)
return result;
}
}
var result = {};
var nodes = [];
var childNodesCount = 0;
var value;
var cursor;
var object;
var name;
var isElement;
var map;
if (cursor = firstChild)
{
do
{
childNodesCount = nodes.push(cursor);
}
while (cursor = cursor.nextSibling);
}
if (attributes)
for (var i = 0, attr; attr = attributes[i]; i++)
nodes.push(attr);
if (!mapping)
mapping = {};
for (var i = 0, child; child = nodes[i]; i++)
{
name = child.nodeName;
isElement = i < childNodesCount;
map = mapping[name];
// fetch value
if (isElement)
{
value = XML2Object(child, mapping);
}
else
{
if (name == 'xmlns')
continue;
value = child.nodeValue;
}
// mapping keys
while (map)
{
if (map.storeName)
value[map.storeName] = name;
if (map.rename)
{
name = map.rename;
map = mapping[name];
}
else
{
if (map.format)
value = map.format(value);
if (!result[name] && map.forceArray)
value = [value];
break;
}
}
// store result
if (name in result)
{
if ((object = result[name]) && object.push)
object.push(value);
else
result[name] = [object, value];
}
else
result[name] = value;
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q54149
|
isPrimitiveObject
|
train
|
function isPrimitiveObject(value){
return typeof value == 'string' || typeof value == 'number' ||
typeof value == 'function' || typeof value == 'boolean' ||
value.constructor === Date || value.constructor === RegExp;
}
|
javascript
|
{
"resource": ""
}
|
q54150
|
XML2String
|
train
|
function XML2String(node){
// modern browsers feature
if (typeof XMLSerializer != 'undefined')
return new XMLSerializer().serializeToString(node);
// old IE feature
if (typeof node.xml == 'string')
return node.xml;
// other browsers
if (node.nodeType == domUtils.DOCUMENT_NODE)
node = node.documentElement;
return domUtils.outerHTML(node);
}
|
javascript
|
{
"resource": ""
}
|
q54151
|
kill
|
train
|
function kill(event, node){
node = getNode(node);
if (node)
addHandler(node, event, kill);
else
{
cancelDefault(event);
cancelBubble(event);
}
}
|
javascript
|
{
"resource": ""
}
|
q54152
|
mouseButton
|
train
|
function mouseButton(event, button){
if (typeof event.which == 'number')
// DOM scheme
return event.which == button.VALUE;
else
// IE6-8
return !!(event.button & button.BIT);
}
|
javascript
|
{
"resource": ""
}
|
q54153
|
mouseX
|
train
|
function mouseX(event){
if ('pageX' in event)
return event.pageX;
else
return 'clientX' in event
? event.clientX +
(document.compatMode == 'CSS1Compat' ? document.documentElement.scrollLeft : document.body.scrollLeft)
: 0;
}
|
javascript
|
{
"resource": ""
}
|
q54154
|
mouseY
|
train
|
function mouseY(event){
if ('pageY' in event)
return event.pageY;
else
return 'clientY' in event
? event.clientY +
(document.compatMode == 'CSS1Compat' ? document.documentElement.scrollTop : document.body.scrollTop)
: 0;
}
|
javascript
|
{
"resource": ""
}
|
q54155
|
wheelDelta
|
train
|
function wheelDelta(event){
var delta = 0;
if ('deltaY' in event)
delta = -event.deltaY; // safari & gecko
else
if ('wheelDelta' in event)
delta = event.wheelDelta; // IE, webkit, opera
else
if (event.type == 'DOMMouseScroll')
delta = -event.detail; // old gecko
return delta && (delta / Math.abs(delta));
}
|
javascript
|
{
"resource": ""
}
|
q54156
|
observeGlobalEvents
|
train
|
function observeGlobalEvents(event){
var handlers = arrayFrom(globalHandlers[event.type]);
var captureHandler = captureHandlers[event.type];
var wrappedEvent = new Event(event);
startFrame(event);
if (captureHandler)
{
captureHandler.handler.call(captureHandler.thisObject, wrappedEvent);
}
else
{
if (handlers)
{
for (var i = handlers.length; i-- > 0;)
{
var handlerObject = handlers[i];
handlerObject.handler.call(handlerObject.thisObject, wrappedEvent);
}
}
}
finishFrame(event);
}
|
javascript
|
{
"resource": ""
}
|
q54157
|
addGlobalHandler
|
train
|
function addGlobalHandler(eventType, handler, thisObject){
var handlers = globalHandlers[eventType];
if (handlers)
{
// search for similar handler, returns if found (prevent for handler dublicates)
for (var i = 0, item; item = handlers[i]; i++)
if (item.handler === handler && item.thisObject === thisObject)
return;
}
else
{
if (noCaptureScheme)
// nothing to do, but it will provide observeGlobalEvents calls if other one doesn't
addHandler(document, eventType, $null);
else
document.addEventListener(eventType, observeGlobalEvents, true);
handlers = globalHandlers[eventType] = [];
}
// add new handler
handlers.push({
handler: handler,
thisObject: thisObject
});
}
|
javascript
|
{
"resource": ""
}
|
q54158
|
removeGlobalHandler
|
train
|
function removeGlobalHandler(eventType, handler, thisObject){
var handlers = globalHandlers[eventType];
if (handlers)
{
for (var i = 0, item; item = handlers[i]; i++)
{
if (item.handler === handler && item.thisObject === thisObject)
{
handlers.splice(i, 1);
if (!handlers.length)
{
delete globalHandlers[eventType];
if (noCaptureScheme)
removeHandler(document, eventType, $null);
else
document.removeEventListener(eventType, observeGlobalEvents, true);
}
return;
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q54159
|
addHandler
|
train
|
function addHandler(node, eventType, handler, thisObject){
node = getNode(node);
if (!node)
throw 'basis.event.addHandler: can\'t attach event listener to undefined';
if (typeof handler != 'function')
throw 'basis.event.addHandler: handler is not a function';
var handlers = node === global ? globalEvents : node[EVENT_HOLDER];
if (!handlers)
handlers = node[EVENT_HOLDER] = {};
var eventTypeHandlers = handlers[eventType];
var handlerObject = {
handler: handler,
thisObject: thisObject
};
if (!eventTypeHandlers)
{
eventTypeHandlers = handlers[eventType] = [handlerObject];
eventTypeHandlers.fireEvent = function(event){ // closure
// simulate capture phase for old browsers
event = wrap(event);
if (noCaptureScheme && event && globalHandlers[eventType])
{
if (typeof event.returnValue == 'undefined')
{
observeGlobalEvents(event);
if (event.cancelBubble === true)
return;
if (typeof event.returnValue == 'undefined')
event.returnValue = true;
}
}
startFrame(event);
// call eventType handlers
for (var i = 0, wrappedEvent = new Event(event), item; item = eventTypeHandlers[i++];)
item.handler.call(item.thisObject, wrappedEvent);
finishFrame(event);
};
if (W3CSUPPORT)
// W3C DOM event model
node.addEventListener(eventType, eventTypeHandlers.fireEvent, false);
else
// old IE event model
node.attachEvent('on' + eventType, eventTypeHandlers.fireEvent);
}
else
{
// check for duplicates, exit if found
for (var i = 0, item; item = eventTypeHandlers[i]; i++)
if (item.handler === handler && item.thisObject === thisObject)
return;
// add only unique handlers
eventTypeHandlers.push(handlerObject);
}
}
|
javascript
|
{
"resource": ""
}
|
q54160
|
addHandlers
|
train
|
function addHandlers(node, handlers, thisObject){
node = getNode(node);
for (var eventType in handlers)
addHandler(node, eventType, handlers[eventType], thisObject);
}
|
javascript
|
{
"resource": ""
}
|
q54161
|
removeHandler
|
train
|
function removeHandler(node, eventType, handler, thisObject){
node = getNode(node);
var handlers = node === global ? globalEvents : node[EVENT_HOLDER];
if (handlers)
{
var eventTypeHandlers = handlers[eventType];
if (eventTypeHandlers)
{
for (var i = 0, item; item = eventTypeHandlers[i]; i++)
{
if (item.handler === handler && item.thisObject === thisObject)
{
// delete event handler
eventTypeHandlers.splice(i, 1);
// if there is no more handler for this event, clear it
if (!eventTypeHandlers.length)
clearHandlers(node, eventType);
return;
}
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q54162
|
clearHandlers
|
train
|
function clearHandlers(node, eventType){
node = getNode(node);
var handlers = node === global ? globalEvents : node[EVENT_HOLDER];
if (handlers)
{
if (typeof eventType != 'string')
{
// no eventType - delete handlers for all events
for (eventType in handlers)
clearHandlers(node, eventType);
}
else
{
// delete eventType handlers
var eventTypeHandlers = handlers[eventType];
if (eventTypeHandlers)
{
if (node.removeEventListener)
node.removeEventListener(eventType, eventTypeHandlers.fireEvent, false);
else
node.detachEvent('on' + eventType, eventTypeHandlers.fireEvent);
delete handlers[eventType];
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q54163
|
onUnload
|
train
|
function onUnload(handler, thisObject){
// deprecated in 1.4
/** @cut */ basis.dev.warn('basis.dom.event.onUnload() is deprecated, use basis.teardown() instead');
basis.teardown(handler, thisObject);
}
|
javascript
|
{
"resource": ""
}
|
q54164
|
highlight
|
train
|
function highlight(text, lang, options){
function makeSafe(str){
return str
.replace(/\r\n|\n\r|\r/g, '\n')
.replace(/&/g, '&')
.replace(/</g, '<');
}
function normalize(text){
text = text
// cut first empty lines
.replace(/^(?:\s*[\n]+)+?([ \t]*)/, '$1')
.trimRight();
// fix empty strings
text = text.replace(/\n[ \t]+\n/g, '\n\n');
// normalize text offset
var minOffset = 1000;
var lines = text.split(/\n+/);
var startLine = Number(text.match(/^function/) != null); // fix for function.toString()
for (var i = startLine; i < lines.length; i++)
{
var m = lines[i].match(/^\s*/);
if (m[0].length < minOffset)
minOffset = m[0].length;
if (minOffset == 0)
break;
}
if (minOffset > 0)
text = text.replace(new RegExp('(^|\\n) {' + minOffset + '}', 'g'), '$1');
return text;
}
function defaultWrapper(line, idx){
return (
'<div class="line ' + (idx % 2 ? 'odd' : 'even') + lineClass + '">' +
'<span class="lineContent">' +
(!options.noLineNumber
? '<input class="lineNumber" value="' + lead(idx + 1, numberWidth) + '" type="none" unselectable="on" readonly="readonly" tabindex="-1" />' +
'<span class="over"></span>'
: ''
) +
line + '\r\n' +
'</span>' +
'</div>'
);
}
// MAIN PART
if (!options)
options = {};
// prepare text
var rangeStart = -1;
var rangeEnd = -1;
var rangeName = '';
if (options.range)
{
var left = makeSafe(text.substr(0, options.range[0]));
var range = makeSafe(text.substring(options.range[0], options.range[1]));
var right = makeSafe(text.substr(options.range[1]));
rangeStart = left.length;
rangeEnd = rangeStart + range.length;
rangeName = options.range[2] || 'range';
text = left + range + right;
}
else
{
text = makeSafe(text);
}
if (!options.keepFormat)
text = normalize(text || '');
var parser = LANG_PARSER[lang] || LANG_PARSER.text;
var html = parser(text, rangeStart, rangeEnd, rangeName);
var lines = html.split('\n');
var numberWidth = String(lines.length).length;
var lineClass = (options.noLineNumber ? '' : ' hasLineNumber');
var offsetRx = new RegExp('^(<span class="' + rangeName + '">)?([ \\t]+)');
lines = lines
.map(function(line){
return line.replace(offsetRx, function(m, rangeSpan, spaces){
return (rangeSpan || '') + repeat('\xA0', spaces.replace(/\t/g, ' ').length);
});
})
.map(options.wrapper || defaultWrapper);
return options.lines ? lines : lines.join('');
}
|
javascript
|
{
"resource": ""
}
|
q54165
|
train
|
function(value){
var oldValue = this.value;
var newValue = this.proxy ? this.proxy(value) : value;
var changed = newValue !== oldValue;
if (changed)
{
if (this.setNullOnEmitterDestroy)
{
if (oldValue instanceof Emitter)
oldValue.removeHandler(VALUE_EMMITER_DESTROY_HANDLER, this);
if (newValue instanceof Emitter)
newValue.addHandler(VALUE_EMMITER_DESTROY_HANDLER, this);
}
this.value = newValue;
if (!this.locked)
this.emit_change(oldValue);
}
return changed;
}
|
javascript
|
{
"resource": ""
}
|
|
q54166
|
train
|
function(){
if (this.locked)
{
this.locked--;
if (!this.locked)
{
var lockedValue = this.lockedValue_;
this.lockedValue_ = null;
if (this.value !== lockedValue)
this.emit_change(lockedValue);
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54167
|
train
|
function(fn){
// obsolete in 1.4
/** @cut */ if (arguments.length > 1)
/** @cut */ basis.dev.warn('basis.data.Value#as() doesn\'t accept deferred flag as second parameter anymore. Use value.as(fn).deferred() instead.');
if (!fn || fn === $self)
return this;
if (typeof fn == 'string')
fn = basis.getter(fn);
if (this.links_)
{
// try to find value with the same function
var cursor = this;
var fnId = fn[GETTER_ID] || String(fn);
while (cursor = cursor.links_)
{
var context = cursor.context;
if (context instanceof ReadOnlyValue &&
context.proxy &&
(context.proxy[GETTER_ID] || String(context.proxy)) == fnId) // compare functions by id
{
/** @cut */ context = devWrap(context);
return context;
}
}
}
// create transform value
var result = new ReadOnlyValue({
proxy: fn,
value: this.value
});
/** @cut */ basis.dev.setInfo(result, 'sourceInfo', {
/** @cut */ type: 'Value#as',
/** @cut */ source: this,
/** @cut */ sourceTarget: this.value,
/** @cut */ transform: fn
/** @cut */ });
/** @cut */ if (fn.retarget)
/** @cut */ {
/** @cut */ result.proxy = function(value){
/** @cut */ value = fn(value);
/** @cut */ basis.dev.patchInfo(result, 'sourceInfo', {
/** @cut */ sourceTarget: value
/** @cut */ });
/** @cut */ return value;
/** @cut */ };
/** @cut */ result.proxy[GETTER_ID] = fn[GETTER_ID]; // set the same GETTER_ID for correct search in links_
/** @cut */ }
this.link(result, valueSyncAs, true, result.destroy);
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q54168
|
isConnected
|
train
|
function isConnected(a, b){
while (b && b !== a && b !== b.delegate)
b = b.delegate;
return b === a;
}
|
javascript
|
{
"resource": ""
}
|
q54169
|
applyDelegateChanges
|
train
|
function applyDelegateChanges(object, oldRoot, oldTarget){
var delegate = object.delegate;
if (delegate)
{
object.root = delegate.root;
object.target = delegate.target;
object.data = delegate.data;
object.state = delegate.state;
}
// fire event if root changed
if (!isEqual(object.root, oldRoot))
{
var rootListenHandler = object.listen.root;
if (rootListenHandler)
{
if (oldRoot && !isEqual(oldRoot, object))
oldRoot.removeHandler(rootListenHandler, object);
if (object.root && !isEqual(object.root, object))
object.root.addHandler(rootListenHandler, object);
}
object.emit_rootChanged(oldRoot);
}
// fire event if target changed
if (!isEqual(object.target, oldTarget))
{
var targetListenHandler = object.listen.target;
if (targetListenHandler)
{
if (oldTarget && !isEqual(oldTarget, object))
oldTarget.removeHandler(targetListenHandler, object);
if (object.target && !isEqual(object.target, object))
object.target.addHandler(targetListenHandler, object);
}
object.emit_targetChanged(oldTarget);
}
var cursor = object.delegates_;
while (cursor)
{
if (cursor.delegate)
applyDelegateChanges(cursor.delegate, oldRoot, oldTarget);
cursor = cursor.next;
}
}
|
javascript
|
{
"resource": ""
}
|
q54170
|
train
|
function(data){
if (this.delegate)
return this.root.update(data);
if (data)
{
var delta = {};
var changed = false;
for (var prop in data)
if (this.data[prop] !== data[prop])
{
changed = true;
delta[prop] = this.data[prop];
this.data[prop] = data[prop];
}
if (changed)
{
this.emit_update(delta);
return delta;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q54171
|
getDatasetDelta
|
train
|
function getDatasetDelta(a, b){
if (!a || !a.itemCount)
{
if (b && b.itemCount)
return {
inserted: b.getItems()
};
}
else
{
if (!b || !b.itemCount)
{
if (a.itemCount)
return {
deleted: a.getItems()
};
}
else
{
var inserted = [];
var deleted = [];
for (var key in a.items_)
{
var item = a.items_[key];
if (item.basisObjectId in b.items_ == false)
deleted.push(item);
}
for (var key in b.items_)
{
var item = b.items_[key];
if (item.basisObjectId in a.items_ == false)
inserted.push(item);
}
return getDelta(inserted, deleted);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q54172
|
train
|
function(count){
var result = [];
if (count)
for (var objectId in this.items_)
if (result.push(this.items_[objectId]) >= count)
break;
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q54173
|
train
|
function(fn){
var items = this.getItems();
for (var i = 0; i < items.length; i++)
fn(items[i]);
}
|
javascript
|
{
"resource": ""
}
|
|
q54174
|
train
|
function(items){
var delta = this.set(items) || {};
var deleted = delta.deleted;
Dataset.setAccumulateState(true);
if (deleted)
for (var i = 0, object; object = deleted[i]; i++)
object.destroy();
Dataset.setAccumulateState(false);
return delta.inserted;
}
|
javascript
|
{
"resource": ""
}
|
|
q54175
|
train
|
function(){
Dataset.flushChanges(this);
var deleted = this.getItems();
var listenHandler = this.listen.item;
var delta;
if (deleted.length)
{
if (listenHandler)
for (var i = 0; i < deleted.length; i++)
deleted[i].removeHandler(listenHandler, this);
this.emit_itemsChanged(delta = {
deleted: deleted
});
this.members_ = {};
}
return delta;
}
|
javascript
|
{
"resource": ""
}
|
|
q54176
|
resolveToken
|
train
|
function resolveToken(path){
if (path.charAt(0) == '#')
{
// return index by absolute index
return tokenIndex[parseInt(path.substr(1), 36)];
}
else
{
var parts = path.match(/^(.+?)@(.+)$/);
if (parts)
return resolveDictionary(basis.path.resolve(parts[2])).token(parts[1]);
/** @cut */ basis.dev.warn('basis.l10n.token accepts token references in format `token.path@path/to/dict.l10n` only');
}
}
|
javascript
|
{
"resource": ""
}
|
q54177
|
train
|
function(){
for (var tokenName in this.tokens)
{
var token = this.tokens[tokenName];
var descriptor = this.getDescriptor(tokenName) || NULL_DESCRIPTOR;
var savedType = token.getType();
token.descriptor = descriptor;
if (token.value !== descriptor.value)
{
// on value change apply will be ivoked and new type applied
basisTokenPrototypeSet.call(token, descriptor.value);
}
else
{
// apply changes if type has been changed
if (token.getType() != savedType)
token.apply();
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q54178
|
internalResolveDictionary
|
train
|
function internalResolveDictionary(source, noFetch) {
var dictionary;
if (typeof source == 'string')
{
var location = source;
var extname = basis.path.extname(location);
if (extname != '.l10n')
location = location.replace(new RegExp(extname + '([#?]|$)'), '.l10n$1');
source = basis.resource(location);
}
if (basis.resource.isResource(source))
dictionary = dictionaryByUrl[source.url];
return dictionary || new Dictionary(source, noFetch);
}
|
javascript
|
{
"resource": ""
}
|
q54179
|
resolveCulture
|
train
|
function resolveCulture(name, pluralForm){
if (name && !cultures[name])
cultures[name] = new Culture(name, pluralForm);
return cultures[name || currentCulture];
}
|
javascript
|
{
"resource": ""
}
|
q54180
|
setCulture
|
train
|
function setCulture(culture){
if (!culture)
return;
if (currentCulture != culture)
{
if (cultureList.indexOf(culture) == -1)
{
/** @cut */ basis.dev.warn('basis.l10n.setCulture: culture `' + culture + '` not in the list, the culture doesn\'t changed');
return;
}
currentCulture = culture;
for (var i = 0, dictionary; dictionary = dictionaries[i]; i++)
dictionary.syncValues();
basisTokenPrototypeSet.call(resolveCulture, culture);
}
}
|
javascript
|
{
"resource": ""
}
|
q54181
|
onCultureChange
|
train
|
function onCultureChange(fn, context, fire){
resolveCulture.attach(fn, context);
if (fire)
fn.call(context, currentCulture);
}
|
javascript
|
{
"resource": ""
}
|
q54182
|
init
|
train
|
function init(_scene, _camera, _params) {
if (!_scene || !(_scene instanceof THREE.Scene)) {
throw new TypeError('Requires THREE.Scene argument');
}
if (!_camera || !(_camera instanceof THREE.Camera)) {
throw new TypeError('Requires THREE.Camera argument');
}
scene = _scene;
camera = _camera;
var p = _params || {};
domElem = p.renderer && p.renderer.domElement || window;
domElem.addEventListener('mousedown', mouseDown, false);
domElem.addEventListener('mouseup', mouseUp, false);
domElem.addEventListener('mousemove', mouseMove, false);
}
|
javascript
|
{
"resource": ""
}
|
q54183
|
Simulation
|
train
|
function Simulation(config)
{
if ( config === void 0 ) config = {auto: true};
this._scene = null;
this._renderer = null;
this._camera = null;
var usingAFrame = window.AFRAME && document.querySelector('a-scene');
if(usingAFrame)
{
var ascene = document.querySelector('a-scene');
this._scene = ascene.object3D;
this._renderer = ascene.renderer;
var acamera = document.querySelector('a-camera');
if(acamera)
{ this._camera = acamera.object3D; }
}
else if (window.altspace && altspace.inClient)
{
this._scene = new THREE.Scene();
this._renderer = altspace.getThreeJSRenderer();
this._camera = new THREE.PerspectiveCamera(); // TODO: change from shim to symbolic
}
else {
this._setupWebGL();
}
if(config.auto && !usingAFrame)
{ this.loop(); }
}
|
javascript
|
{
"resource": ""
}
|
q54184
|
init$1
|
train
|
function init$1(params){
var p = params || {};
TRACE = p.TRACE || false;
if (p.crossOrigin) { crossOrigin = p.crossOrigin; }
if (p.baseUrl) { baseUrl = p.baseUrl; }
if (baseUrl.slice(-1) !== '/') { baseUrl += '/'; }
loader = new altspace.utilities.shims.OBJMTLLoader();
loader.crossOrigin = crossOrigin;
if (TRACE) { console.log('MultiLoader initialized with params', params); }
}
|
javascript
|
{
"resource": ""
}
|
q54185
|
ensureInVR
|
train
|
function ensureInVR() {
if (inTile || !inVR) //inTile && inAltspace
{
var css = document.createElement("style");
css.type = "text/css";
css.innerHTML = "@import url(https://fonts.googleapis.com/css?family=Open+Sans:800);.altspace-info{text-align:center;font-family:'Open Sans',sans-serif;line-height:.5}.altspace-vr-notice{color:rgba(0,0,0,.7);font-size:5vw}.altspace-pen-name{font-size:7vw}";
document.head.appendChild(css);
document.body.style.background = Please.make_color({ seed: getPenId() });
var info = document.createElement("div");
info.className = "altspace-info";
document.body.appendChild(info);
var nameEl = document.createElement("span");
nameEl.className = "altspace-pen-name";
nameEl.innerHTML = '<p>' + name.toUpperCase() + '</p>';
info.appendChild(nameEl);
if (inTile) {
var errorMsg = 'VR mode does not support preview tiles. Stopping code execution.';
console.log('ERROR: ' + errorMsg);
throw new Error(errorMsg);
}
if (!inVR) {
var launchEl = document.createElement("span");
launchEl.className = "altspace-vr-notice";
launchEl.innerHTML = '<p>View</p>';
info.insertBefore(launchEl, nameEl);
var notice = document.createElement("span");
notice.className = "altspace-vr-notice";
notice.innerHTML = '<p>in <a href="http://altvr.com"> AltspaceVR </a></p>';
info.appendChild(notice);
var errorMsg = 'Not in VR mode. Stopping code execution.';
if (inTile) {
console.log('ERROR: ' + errorMsg);//thrown error message not displayed in console when inTile, log it
}
throw new Error(errorMsg);
}
return;
}
}
|
javascript
|
{
"resource": ""
}
|
q54186
|
getPenId
|
train
|
function getPenId() {
var url = getParsedUrl();
var splitPath = url.path.split('/');
var id = splitPath[splitPath.length - 1];
return id;
}
|
javascript
|
{
"resource": ""
}
|
q54187
|
getAuthorId
|
train
|
function getAuthorId() {
var url = getParsedUrl();
var splitPath = url.path.split('/');
var isTeam = splitPath[1] == 'team';
var id = isTeam ? 'team-' + splitPath[2] : splitPath[1];
return id;
}
|
javascript
|
{
"resource": ""
}
|
q54188
|
isEqual
|
train
|
function isEqual(a, b)
{
// objects are directly equal
if(a === b){
return true;
}
// recurse for each pair of array items
else if( Array.isArray(a) && Array.isArray(b) && a.length === b.length ){
return a.every( function (v,i) { return isEqual(a[i], b[i]); } );
}
// recurse for every key/val pair in objects
else if( a instanceof Object && b instanceof Object
&& isEqual(Object.keys(a).sort(), Object.keys(b).sort()) )
{
for(var k in a){
if( !isEqual(a[k], b[k]) )
{ return false; }
}
return true;
}
else {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q54189
|
flattenSkeleton
|
train
|
function flattenSkeleton(skeleton) {
var list = [];
var walk = function(parentid, node, list) {
var bone = {};
bone.name = node.sid;
bone.parent = parentid;
bone.matrix = node.matrix;
var data = [ new THREE.Vector3(),new THREE.Quaternion(),new THREE.Vector3() ];
bone.matrix.decompose(data[0], data[1], data[2]);
bone.pos = [ data[0].x,data[0].y,data[0].z ];
bone.scl = [ data[2].x,data[2].y,data[2].z ];
bone.rotq = [ data[1].x,data[1].y,data[1].z,data[1].w ];
list.push(bone);
for (var i in node.nodes) {
walk(node.sid, node.nodes[i], list);
}
};
walk(-1, skeleton, list);
return list;
}
|
javascript
|
{
"resource": ""
}
|
q54190
|
skinToBindPose
|
train
|
function skinToBindPose(geometry,skeleton,skinController) {
var bones = [];
setupSkeleton( skeleton, bones, -1 );
setupSkinningMatrices( bones, skinController.skin );
var v = new THREE.Vector3();
var skinned = [];
for (var i = 0; i < geometry.vertices.length; i ++) {
skinned.push(new THREE.Vector3());
}
for ( i = 0; i < bones.length; i ++ ) {
if ( bones[ i ].type != 'JOINT' ) continue;
for ( var j = 0; j < bones[ i ].weights.length; j ++ ) {
var w = bones[ i ].weights[ j ];
var vidx = w.index;
var weight = w.weight;
var o = geometry.vertices[vidx];
var s = skinned[vidx];
v.x = o.x;
v.y = o.y;
v.z = o.z;
v.applyMatrix4( bones[i].skinningMatrix );
s.x += (v.x * weight);
s.y += (v.y * weight);
s.z += (v.z * weight);
}
}
for (var i = 0; i < geometry.vertices.length; i ++) {
geometry.vertices[i] = skinned[i];
}
}
|
javascript
|
{
"resource": ""
}
|
q54191
|
getNextKeyWith
|
train
|
function getNextKeyWith( keys, fullSid, ndx ) {
for ( ; ndx < keys.length; ndx ++ ) {
var key = keys[ ndx ];
if ( key.hasTarget( fullSid ) ) {
return key;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q54192
|
getPrevKeyWith
|
train
|
function getPrevKeyWith( keys, fullSid, ndx ) {
ndx = ndx >= 0 ? ndx : ndx + keys.length;
for ( ; ndx >= 0; ndx -- ) {
var key = keys[ ndx ];
if ( key.hasTarget( fullSid ) ) {
return key;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q54193
|
setUpConversion
|
train
|
function setUpConversion() {
if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) {
upConversion = null;
} else {
switch ( colladaUp ) {
case 'X':
upConversion = options.upAxis === 'Y' ? 'XtoY' : 'XtoZ';
break;
case 'Y':
upConversion = options.upAxis === 'X' ? 'YtoX' : 'YtoZ';
break;
case 'Z':
upConversion = options.upAxis === 'X' ? 'ZtoX' : 'ZtoY';
break;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q54194
|
replaceTHREEShaderAttributes
|
train
|
function replaceTHREEShaderAttributes( shaderText, technique ) {
// Expected technique attributes
var attributes = {};
for ( var attributeId in technique.attributes ) {
var pname = technique.attributes[ attributeId ];
var param = technique.parameters[ pname ];
var atype = param.type;
var semantic = param.semantic;
attributes[ attributeId ] = {
type: atype,
semantic: semantic
};
}
// Figure out which attributes to change in technique
var shaderParams = technique.parameters;
var shaderAttributes = technique.attributes;
var params = {};
for ( var attributeId in attributes ) {
var pname = shaderAttributes[ attributeId ];
var shaderParam = shaderParams[ pname ];
var semantic = shaderParam.semantic;
if ( semantic ) {
params[ attributeId ] = shaderParam;
}
}
for ( var pname in params ) {
var param = params[ pname ];
var semantic = param.semantic;
var regEx = new RegExp( "\\b" + pname + "\\b", "g" );
switch ( semantic ) {
case "POSITION":
shaderText = shaderText.replace( regEx, 'position' );
break;
case "NORMAL":
shaderText = shaderText.replace( regEx, 'normal' );
break;
case 'TEXCOORD_0':
case 'TEXCOORD0':
case 'TEXCOORD':
shaderText = shaderText.replace( regEx, 'uv' );
break;
case 'COLOR_0':
case 'COLOR0':
case 'COLOR':
shaderText = shaderText.replace( regEx, 'color' );
break;
case "WEIGHT":
shaderText = shaderText.replace( regEx, 'skinWeight' );
break;
case "JOINT":
shaderText = shaderText.replace( regEx, 'skinIndex' );
break;
}
}
return shaderText;
}
|
javascript
|
{
"resource": ""
}
|
q54195
|
getController
|
train
|
function getController(hand, config) {
const findGamepad = (resolve, reject) => {
const gamepad = altspace.getGamepads().find((g) => g.mapping === 'steamvr' && g.hand === hand);
if (gamepad) {
if(config.logging) console.log("SteamVR input device found", gamepad);
resolve(gamepad);
} else {
if(config.logging) console.log("SteamVR input device not found trying again in 500ms...");
setTimeout(findGamepad, 500, resolve, reject);
}
};
return new Promise(findGamepad);
}
|
javascript
|
{
"resource": ""
}
|
q54196
|
spawn
|
train
|
function spawn(exe, args, cwd) {
const deferred = Q.defer();
const child = cp.spawn(exe, args, {cwd: cwd || process.cwd()});
const buffer = [];
child.stderr.on('data', chunk => {
buffer.push(chunk.toString());
});
child.stdout.on('data', chunk => {
deferred.notify(chunk);
});
child.on('close', code => {
if (code) {
const msg = buffer.join('') || `Process failed: ${code}`;
deferred.reject(new ProcessError(code, msg));
} else {
deferred.resolve(code);
}
});
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q54197
|
makeDir
|
train
|
function makeDir(path, callback) {
fs.mkdir(path, err => {
if (err) {
// check if directory exists
fs.stat(path, (err2, stat) => {
if (err2 || !stat.isDirectory()) {
callback(err);
} else {
callback();
}
});
} else {
callback();
}
});
}
|
javascript
|
{
"resource": ""
}
|
q54198
|
mustPreserveItems
|
train
|
function mustPreserveItems(state) {
let plugins = state.plugins
if (cachedPreserveItemsPlugins != plugins) {
cachedPreserveItems = false
cachedPreserveItemsPlugins = plugins
for (let i = 0; i < plugins.length; i++) if (plugins[i].spec.historyPreserveItems) {
cachedPreserveItems = true
break
}
}
return cachedPreserveItems
}
|
javascript
|
{
"resource": ""
}
|
q54199
|
Hook
|
train
|
function Hook(hookName, taskNames, options) {
/**
* The name of the hook
* @property hookName
* @type {String}
*/
this.hookName = hookName;
/**
* The name of the tasks that should be run by the hook, space separated
* @property taskNames
* @type {String}
*/
this.taskNames = taskNames;
/**
* Options for the creation of the hook
* @property options
* @type {Object}
*/
this.options = options || {};
this.markerRegExp = new RegExp(this.options.startMarker.replace(/\//g, '\\/') +
'[\\s\\S]*' + // Not .* because it needs to match \n
this.options.endMarker.replace(/\//g, '\\/'), 'm');
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.