dataset.forEach((data) => {
if (data.category !== undefined && !includes(categories, data.category)) {
categories.push(data.category);
} else if (!includes(axisValues, data[axis])) {
axisValues.push(data[axis]);
}
});
importSpecifier(specifier, node, nodes) {
var key = node.source.value;
var ref = this.getExternalReference(node);
if (t.isImportNamespaceSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
this.defaultIds[key] = specifier.local;
}
if (includes(this.file.dynamicImportedNoDefault, node)) {
// Prevent unnecessary renaming of dynamic imports.
this.ids[node.source.value] = ref;
} else if (t.isImportNamespaceSpecifier(specifier)) {
// import * as bar from "foo";
} else if (!includes(this.file.dynamicImported, node) && t.isSpecifierDefault(specifier) && !this.noInteropRequireImport) {
// import foo from "foo";
ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
} else {
// import { foo } from "foo";
var imported = specifier.imported;
if (t.isSpecifierDefault(specifier)) imported = t.identifier("default");
ref = t.memberExpression(ref, imported);
}
nodes.push(t.variableDeclaration("var", [
t.variableDeclarator(specifier.local, ref)
]));
}
TransformerPass.prototype.canRun = function () {
var transformer = this.transformer;
var opts = this.file.opts;
var key = transformer.key;
// internal
if (key[0] === "_") return true;
// blacklist
var blacklist = opts.blacklist;
if (blacklist.length && includes(blacklist, key)) return false;
// whitelist
var whitelist = opts.whitelist;
if (whitelist.length) return includes(whitelist, key);
// optional
if (transformer.optional && !includes(opts.optional, key)) return false;
// experimental
if (transformer.experimental && !opts.experimental) return false;
// playground
if (transformer.playground && !opts.playground) return false;
return true;
};
addHelper(name: string): Object {
var isSolo = includes(File.soloHelpers, name);
if (!isSolo && !includes(File.helpers, name)) {
throw new ReferenceError(`Unknown helper ${name}`);
}
var program = this.ast.program;
var declar = this.declarations[name];
if (declar) return declar;
this.usedHelpers[name] = true;
if (!isSolo) {
var generator = this.get("helperGenerator");
var runtime = this.get("helpersNamespace");
if (generator) {
return generator(name);
} else if (runtime) {
var id = t.identifier(t.toIdentifier(name));
return t.memberExpression(runtime, id);
}
}
var ref = util.template("helper-" + name);
ref._compact = true;
var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
this.scope.push({
id: uid,
init: ref,
unique: true
});
return uid;
}
canTransform(): boolean {
var transformer = this.transformer;
var opts = this.file.opts;
var key = transformer.key;
// internal
if (key[0] === "_") return true;
// blacklist
var blacklist = opts.blacklist;
if (blacklist.length && includes(blacklist, key)) return false;
// whitelist
var whitelist = opts.whitelist;
if (whitelist) return includes(whitelist, key);
// stage
var stage = transformer.metadata.stage;
if (stage != null && stage >= opts.stage) return true;
// optional
if (transformer.metadata.optional && !includes(opts.optional, key)) return false;
return true;
}
hasBinding(name: string, noGlobals?) {
if (!name) return false;
if (this.hasOwnBinding(name)) return true;
if (this.parentHasBinding(name, noGlobals)) return true;
if (this.hasUid(name)) return true;
if (!noGlobals && includes(Scope.globals, name)) return true;
if (!noGlobals && includes(Scope.contextVariables, name)) return true;
return false;
}
hasBinding(name: string) {
if (!name) return false;
if (this.hasOwnBinding(name)) return true;
if (this.parentHasBinding(name)) return true;
if (this.file.uids[name]) return true;
if (includes(Scope.globals, name)) return true;
if (includes(Scope.contextVariables, name)) return true;
return false;
}
Scope.prototype.hasBinding = function hasBinding(name) {
if (!name) return false;
if (this.hasOwnBinding(name)) return true;
if (this.parentHasBinding(name)) return true;
if (includes(Scope.globals, name)) return true;
return false;
};
TraversalPath.prototype.replaceNode = function (replacement) {
var isArray = Array.isArray(replacement);
// inherit comments from original node to the first replacement node
var inheritTo = replacement;
if (isArray) inheritTo = replacement[0];
if (inheritTo) t.inheritsComments(inheritTo, this.getNode());
// replace the node
this.setNode(replacement);
var file = this.scope && this.scope.file;
if (file) {
if (isArray) {
for (var i = 0; i < replacement.length; i++) {
file.checkNode(replacement[i], this.scope);
}
} else {
file.checkNode(replacement, this.scope);
}
}
// we're replacing a statement or block node with an array of statements so we better
// ensure that it's a block
if (isArray) {
if (includes(t.STATEMENT_OR_BLOCK_KEYS, this.key) && !t.isBlockStatement(this.obj)) {
t.ensureBlock(this.obj, this.key);
}
this.flatten();
}
};
isStatementOrBlock() {
if (t.isLabeledStatement(this.parent) || t.isBlockStatement(this.container)) {
return false;
} else {
return includes(t.STATEMENT_OR_BLOCK_KEYS, this.key);
}
}
var items = __map(this.props.options, function (option, i) {
var checked = __includes(this.props.value, option.value);
if (this.props.className) {
return (
<label className={this.props.className} key={'c' + i}>
<input {...this.props} type="checkbox" value={option.value} checked={checked}
onChange={this.onChange}/>
{option.label}
</label>
);
} else {
return (
<div className="col-xs-12 col-md-6 col-lg-4" key={'c' + i}>
<div className="checkbox" style={{marginTop:0,marginBottom:0}}>
<label>
<input {...this.props} type="checkbox" value={option.value} checked={checked}
onChange={this.onChange}/>
{option.label}
</label>
</div>
</div>
);
}
}.bind(this));
function getSelectedStudio(studioSlugFromUrl, studioSlugs) {
let selected = 'london';
if(includes(studioSlugs, studioSlugFromUrl)) {
selected = studioSlugFromUrl;
}
return selected;
}
importSpecifier(specifier, node, nodes, scope) {
var key = node.source.value;
var ref = this.getExternalReference(node);
if (t.isImportNamespaceSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
this.defaultIds[key] = specifier.local;
}
if (this.isModuleType(node, "absolute")) {
// absolute module reference
} else if (this.isModuleType(node, "absoluteDefault")) {
// prevent unnecessary renaming of dynamic imports
this.ids[node.source.value] = ref;
ref = t.memberExpression(ref, t.identifier("default"));
} else if (t.isImportNamespaceSpecifier(specifier)) {
// import * as bar from "foo";
} else if (!includes(this.file.dynamicImported, node) && t.isSpecifierDefault(specifier) && !this.noInteropRequireImport) {
// import foo from "foo";
var uid = scope.generateUidIdentifier(specifier.local.name);
nodes.push(t.variableDeclaration("var", [
t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
]));
ref = t.memberExpression(uid, t.identifier("default"));
} else {
// import { foo } from "foo";
var imported = specifier.imported;
if (t.isSpecifierDefault(specifier)) imported = t.identifier("default");
ref = t.memberExpression(ref, imported);
}
this.remaps.add(scope, specifier.local.name, ref);
}
File.prototype.addHelper = function (name) {
if (!includes(File.helpers, name)) {
throw new ReferenceError("Unknown helper " + name);
}
var program = this.ast.program;
var declar = program._declarations && program._declarations[name];
if (declar) return declar.id;
var runtime = this.get("helpersNamespace");
if (runtime) {
name = t.identifier(t.toIdentifier(name));
return t.memberExpression(runtime, name);
} else {
var ref = util.template(name);
ref._compact = true;
var uid = this.scope.generateUidIdentifier(name);
this.scope.push({
key: name,
id: uid,
init: ref
});
return uid;
}
};
addHelper(name: string): Object {
var isSolo = includes(File.soloHelpers, name);
if (!isSolo && !includes(File.helpers, name)) {
throw new ReferenceError(`Unknown helper ${name}`);
}
var program = this.ast.program;
var declar = this.declarations[name];
if (declar) return declar;
this.usedHelpers[name] = true;
if (!isSolo) {
var generator = this.get("helperGenerator");
var runtime = this.get("helpersNamespace");
if (generator) {
return generator(name);
} else if (runtime) {
var id = t.identifier(t.toIdentifier(name));
return t.memberExpression(runtime, id);
}
}
var ref = util.template("helper-" + name);
var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
if (t.isFunctionExpression(ref) && !ref.id) {
ref.body._compact = true;
ref._generated = true;
ref.id = uid;
ref.type = "FunctionDeclaration";
this.attachAuxiliaryComment(ref);
this.path.unshiftContainer("body", ref);
} else {
ref._compact = true;
this.scope.push({
id: uid,
init: ref,
unique: true
});
}
return uid;
}
convert(name, selector) {
let _fn = ()=> {
let font = find(this.fontList, {name})
let info = $(font.fnt).find("info")
let common = $(font.fnt).find("common")
let pages = $(font.fnt).find("pages > page")
let chars = $(font.fnt).find("chars > char")
let text
let els = $(selector)
if (els.length == 0) return
each(els, (el)=> {
$(el).addClass('clearfix')
text = el.innerText
// text hide
el.style.font = '0/0 a'
el.style.color = 'transparent'
el.style.visibility = 'visible'
el.style.opacity = '1'
for(let i = 0, max = text.length; i < max; i++) {
let code = text.charAt(i).charCodeAt()
each(chars, (char, index)=> {
char = $(char)
let page = parseInt(char.attr('page'))
let file = pages.eq(page).attr('file')
let fontpng = `${font.path}${file}`
if (code == char.attr('id')) {
$("<span>").css({
background: `url(${fontpng})`,
backgroundRepeat: "no-repeat",
backgroundPosition: `-${char.attr('x')}px -${char.attr('y')}px`,
width: `${char.attr('width')}px`,
height: `${char.attr('height')}px`,
marginTop: `${char.attr('yoffset')}px`,
marginRight: `${char.attr('xadvance') - char.attr('width')}px`,
marginBottom: `${common.attr('lineHeight') - char.attr('yoffset') - char.attr('height')}px`,
marginLeft: `${char.attr('xoffset')}px`,
float: "left",
}).appendTo(el)
}
})
}
})
}
if(includes(this.fontList, name)) {
_fn()
}
else {
this.on('fontloaded', ({name})=> {
_fn()
})
}
}
module.dependencies.forEach( function( dep ) {
if ( ! dep.module ) {
return;
}
// If the module is compiled through babel, we can be pretty sure it's our own module, not from npm.
if ( includes( dep.module.request, 'babel-loader' ) &&
dep.module._source &&
! includes( IGNORED_MODULES, dep.request ) &&
! includes( dep.module._source._value, SSR_READY ) ) {
compilation.errors.push( PLUGIN_TITLE + ': ' + module.rawRequest + ', dependency ' + dep.module.rawRequest + ' is not ' + SSR_READY );
}
if ( dep.module.dependencies ) {
scanDependencies( dep.module.dependencies );
}
} );
const validScale = (scl) => {
if (isFunction(scl)) {
return (isFunction(scl.copy) && isFunction(scl.domain) && isFunction(scl.range));
} else if (typeof scl === "string") {
return includes(supportedScaleStrings, scl);
}
return false;
};
/**
* @method _addForeignKeyToRegistry
* @param type
* @param fk
* @private
*/
_addForeignKeyToRegistry(type, fk) {
this._registry[type] = this._registry[type] || { class: null, foreignKeys: [] };
let fks = this._registry[type].foreignKeys;
if (!_includes(fks, fk)) {
fks.push(fk);
}
}
function attachTaskMarkers(p, element, taskMarkers) {
var obj = getSemantic(element);
var subprocess = includes(taskMarkers, 'SubProcessMarker');
var position;
if (subprocess) {
position = {
seq: -21,
parallel: -22,
compensation: -42,
loop: -18,
adhoc: 10
};
} else {
position = {
seq: -3,
parallel: -6,
compensation: -27,
loop: 0,
adhoc: 10
};
}
forEach(taskMarkers, function(marker) {
renderer(marker)(p, element, position);
});
if (obj.isForCompensation) {
renderer('CompensationMarker')(p, element, position);
}
if (obj.$type === 'bpmn:AdHocSubProcess') {
renderer('AdhocMarker')(p, element, position);
}
var loopCharacteristics = obj.loopCharacteristics,
isSequential = loopCharacteristics && loopCharacteristics.isSequential;
if (loopCharacteristics) {
if (isSequential === undefined) {
renderer('LoopMarker')(p, element, position);
}
if (isSequential === false) {
renderer('ParallelMarker')(p, element, position);
}
if (isSequential === true) {
renderer('SequentialMarker')(p, element, position);
}
}
}
exports.testInvalidGreenPin = function(test) {
try {
new BeagleBoneBlack({
"green-pins": ["invalid-pin-name"]
});
test.ok(false, "Expected invalid pin error");
} catch (e) {
test.ok(collection_includes(e.message, "Cannot find green pin"), "Unexpected error with message `"+ e.message +"'");
}
test.done();
};
catchUp(node) {
// catch up to this nodes first token if we're behind
// TODO
for (let i = this._index; i < node.tokenStart; i++) {
let token = this.tokens[i];
if (includes(['Whitespace', 'CommentLine', 'CommentBlock'], token.type)) {
// console.log('catchup', i);
this._push(token);
}
}
this._index = node.tokenStart;
}
isLast(cha) {
if (this.format.compact) return false;
var buf = this.buf;
var last = buf[buf.length - 1];
if (Array.isArray(cha)) {
return includes(cha, last);
} else {
return cha === last;
}
}
generateGalleryShortcode: function( settings ) {
var attrs;
if ( ! settings.items.length ) {
return;
}
// gallery images are passed in as an array of objects
// in settings.items but we just need the IDs set to attrs.ids
attrs = Object.assign( {
ids: settings.items.map( ( item ) => item.ID ).join()
}, settings );
delete attrs.items;
if ( ! includes( GalleryColumnedTypes, attrs.type ) ) {
delete attrs.columns;
}
if ( ! includes( GallerySizeableTypes, attrs.type ) ) {
delete attrs.size;
}
attrs = omit( attrs, function( value, key ) {
return GalleryDefaultAttrs[ key ] === value;
} );
// WordPress expects all lowercase
if ( attrs.orderBy ) {
attrs.orderby = attrs.orderBy;
delete attrs.orderBy;
}
return Shortcode.stringify( {
tag: 'gallery',
type: 'single',
attrs: attrs
} );
},
CommonJSFormatter.prototype.importSpecifier = function (specifier, node, nodes) {
var variableName = t.getSpecifierName(specifier);
var ref = this.getExternalReference(node, nodes);
// import foo from "foo";
if (t.isSpecifierDefault(specifier)) {
if (!includes(this.file.dynamicImportedNoDefault, node)) {
if (this.noInteropRequireImport || includes(this.file.dynamicImported, node)) {
ref = t.memberExpression(ref, t.identifier("default"));
} else {
ref = t.callExpression(this.file.addHelper("interop-require"), [ref]);
}
}
nodes.push(t.variableDeclaration("var", [t.variableDeclarator(variableName, ref)]));
} else {
if (specifier.type === "ImportBatchSpecifier") {
if (!this.noInteropRequireImport) {
ref = t.callExpression(this.file.addHelper("interop-require-wildcard"), [ref]);
}
// import * as bar from "foo";
nodes.push(t.variableDeclaration("var", [
t.variableDeclarator(variableName, ref)
]));
} else {
// import { foo } from "foo";
nodes.push(t.variableDeclaration("var", [
t.variableDeclarator(
variableName,
t.memberExpression(ref, t.getSpecifierId(specifier))
)
]));
}
}
};
test('_getRelatedModelWithPath belongsTo', function(assert) {
let serializer = new (JsonApiSerializer.extend())();
let schema = schemaHelper.setup();
let foo = schema.foo.create();
let bar = foo.createBar();
foo.save();
let baz = bar.createBaz();
bar.save();
let quux1 = baz.createQuux();
let quux2 = baz.createQuux();
baz.save();
let zomg1 = quux1.createZomg();
let zomg2 = quux1.createZomg();
quux1.save();
let zomg3 = quux2.createZomg();
let zomg4 = quux2.createZomg();
quux2.save();
let lol1 = zomg1.createLol();
let lol2 = zomg2.createLol();
let lol3 = zomg3.createLol();
let lol4 = zomg4.createLol();
zomg1.save();
zomg2.save();
zomg3.save();
zomg4.save();
let result = serializer._getRelatedWithPath(foo, 'bar.baz.quuxes.zomgs.lol');
let ids = _map(result, 'id');
assert.equal(result.length, 4);
assert.ok(_includes(ids, lol1.id));
assert.ok(_includes(ids, lol2.id));
assert.ok(_includes(ids, lol3.id));
assert.ok(_includes(ids, lol4.id));
});
it( 'should add a new category regardless of categoryStoreId', function() {
var categories, categoryIds;
common.dispatchReceiveCategoryTerms();
assert.equal( defaultCategoryStore.all( common.TEST_SITE_ID ).length, common.TEST_NUM_CATEGORIES );
common.dispatchAddTerm( 'some_other_category_store_id' );
categories = defaultCategoryStore.all( common.TEST_SITE_ID );
assert.equal( defaultCategoryStore.all( common.TEST_SITE_ID ).length, common.TEST_NUM_CATEGORIES + 1 );
categoryIds = categories.map( function( category ) {
return category.ID;
} );
assert.isTrue( includes( categoryIds, common.TEST_ADDED_TERM.ID ) );
} );
load(name, path) {
if(!includes(this.fontList, name)) {
$.ajax({
url: `${path}${name}.fnt`,
dataType: 'xml',
success: (fnt)=> {
let font = {fnt, name, path}
this.fontList.push(font)
this.fire('fontloaded', font)
},
error: ()=> {
console.error('字体加载出错！')
}
})
}
}
traverse.hasType = function (tree, scope, type, blacklistTypes) {
// the node we're searching in is blacklisted
if (includes(blacklistTypes, tree.type)) return false;
// the type we're looking for is the same as the passed node
if (tree.type === type) return true;
var state = {
has: false,
type: type
};
traverse(tree, {
blacklist: blacklistTypes,
enter: hasBlacklistedType
}, scope, state);
return state.has;
};
function validateField( { name, value, type } ) {
switch ( name ) {
case 'name':
return isValidName( value, type );
case 'target':
return isValidDomain( value, type );
case 'data':
return isValidData( value, type );
case 'protocol':
return includes( [ 'tcp', 'udp', 'tls' ], value );
case 'weight':
case 'aux':
case 'port':
return value.toString().match( /^\d{1,5}$/ );
case 'service':
return value.match( /^[^\s\.]+$/ );
default:
return true;
}
}