_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q53400
|
processNonSpecifier
|
train
|
function processNonSpecifier() {
const secondToken = sourceCode.getFirstToken(node, 1)
if (isLeftBrace(secondToken)) {
setOffsetToToken(
[
secondToken,
sourceCode.getTokenAfter(secondToken),
],
0,
importToken
)
tokens.push(
sourceCode.getLastToken(node, hasSemi ? 2 : 1), // from
sourceCode.getLastToken(node, hasSemi ? 1 : 0) // "foo"
)
} else {
tokens.push(
sourceCode.getLastToken(node, hasSemi ? 1 : 0)
)
}
}
|
javascript
|
{
"resource": ""
}
|
q53401
|
processImportDefaultSpecifier
|
train
|
function processImportDefaultSpecifier() {
if (
secondSpecifier &&
secondSpecifier.type === "ImportNamespaceSpecifier"
) {
// There is a pattern:
// import Foo, * as foo from "foo"
tokens.push(
sourceCode.getFirstToken(firstSpecifier), // Foo
sourceCode.getTokenAfter(firstSpecifier), // comma
sourceCode.getFirstToken(secondSpecifier), // *
sourceCode.getLastToken(node, hasSemi ? 2 : 1), // from
sourceCode.getLastToken(node, hasSemi ? 1 : 0) // "foo"
)
} else {
// There are 3 patterns:
// import Foo from "foo"
// import Foo, {} from "foo"
// import Foo, {a} from "foo"
const idToken = sourceCode.getFirstToken(firstSpecifier)
const nextToken = sourceCode.getTokenAfter(
firstSpecifier
)
if (isComma(nextToken)) {
const leftBrace = sourceCode.getTokenAfter(
nextToken
)
const rightBrace = sourceCode.getLastToken(
node,
hasSemi ? 3 : 2
)
setOffsetToToken(
[idToken, nextToken],
1,
importToken
)
setOffsetToToken(leftBrace, 0, idToken)
processNodeList(
node.specifiers.slice(1),
leftBrace,
rightBrace,
1
)
tokens.push(
sourceCode.getLastToken(node, hasSemi ? 2 : 1), // from
sourceCode.getLastToken(node, hasSemi ? 1 : 0) // "foo"
)
} else {
tokens.push(
idToken,
nextToken, // from
sourceCode.getTokenAfter(nextToken) // "foo"
)
}
}
}
|
javascript
|
{
"resource": ""
}
|
q53402
|
processImportNamespaceSpecifier
|
train
|
function processImportNamespaceSpecifier() {
tokens.push(
sourceCode.getFirstToken(firstSpecifier), // *
sourceCode.getLastToken(node, hasSemi ? 2 : 1), // from
sourceCode.getLastToken(node, hasSemi ? 1 : 0) // "foo"
)
}
|
javascript
|
{
"resource": ""
}
|
q53403
|
processOtherSpecifier
|
train
|
function processOtherSpecifier() {
const leftBrace = sourceCode.getFirstToken(node, 1)
const rightBrace = sourceCode.getLastToken(
node,
hasSemi ? 3 : 2
)
setOffsetToToken(leftBrace, 0, importToken)
processNodeList(node.specifiers, leftBrace, rightBrace, 1)
tokens.push(
sourceCode.getLastToken(node, hasSemi ? 2 : 1), // from
sourceCode.getLastToken(node, hasSemi ? 1 : 0) // "foo"
)
}
|
javascript
|
{
"resource": ""
}
|
q53404
|
getLastLocationInTag
|
train
|
function getLastLocationInTag(node) {
const tagClose = node.tagClose
const text = sourceCode.text.slice(node.range[0], tagClose.range[0])
const index = text.search(/\S\s*$/gu) + node.range[0] + 1
return {
index,
loc: sourceCode.getLocFromIndex(index),
}
}
|
javascript
|
{
"resource": ""
}
|
q53405
|
locationInRangeLoc
|
train
|
function locationInRangeLoc(loc, start, end) {
if (loc.line < start.line || end.line < loc.line) {
return false
}
if (loc.line === start.line) {
if (start.column > loc.column) {
return false
}
}
if (loc.line === end.line) {
if (loc.column >= end.column) {
return false
}
}
return true
}
|
javascript
|
{
"resource": ""
}
|
q53406
|
commentContainsWarningTerm
|
train
|
function commentContainsWarningTerm(comment) {
const matches = []
warningRegExps.forEach((regex, index) => {
if (regex.test(comment)) {
matches.push(warningTerms[index])
}
})
return matches
}
|
javascript
|
{
"resource": ""
}
|
q53407
|
postprocessForDisableRules
|
train
|
function postprocessForDisableRules(messages, microTemplateService) {
const option = microTemplateService.systemOption || {}
const ignoreRules = DISABLED_RULES.concat(option.ignoreRules || [])
const globals = GLOBALS.concat(option.globals || [])
return messages.filter(message => {
if (ignoreRules.indexOf(message.ruleId) >= 0) {
return false
}
if (
microTemplateService.inTemplate(message) &&
TEMPLATE_DISABLED_RULES.indexOf(message.ruleId) >= 0
) {
return false
}
if (
microTemplateService.inInterpolateOrEscape(message) &&
TMPL_INTERPOLATE_DISABLED_RULES.indexOf(message.ruleId) >= 0
) {
return false
}
if (
microTemplateService.inDelimiterMarks(message) &&
TMPL_DELIMITERS_DISABLED_RULES.indexOf(message.ruleId) >= 0
) {
return false
}
if (message.ruleId === "no-undef") {
if (
globals
.map(g => `'${g}' is not defined.`)
.indexOf(message.message) >= 0
) {
return false
}
}
if (message.ruleId === "quotes") {
if (message.message === "Strings must use doublequote.") {
return false
}
}
return true
})
}
|
javascript
|
{
"resource": ""
}
|
q53408
|
tryParseSelector
|
train
|
function tryParseSelector(rawSelector) {
try {
return esquery.parse(rawSelector.replace(/:exit$/u, ""))
} catch (err) {
if (typeof err.offset === "number") {
throw new Error(
`Syntax error in selector "${rawSelector}" at position ${
err.offset
}: ${err.message}`
)
}
throw err
}
}
|
javascript
|
{
"resource": ""
}
|
q53409
|
parseSelector
|
train
|
function parseSelector(rawSelector) {
const parsedSelector = tryParseSelector(rawSelector)
return {
rawSelector,
isExit: rawSelector.endsWith(":exit"),
parsedSelector,
}
}
|
javascript
|
{
"resource": ""
}
|
q53410
|
traverse
|
train
|
function traverse(tokens, options) {
const traverser = new Traverser()
const nodes = Array.isArray(tokens) ? tokens : [tokens]
for (const node of nodes) {
traverser.traverse(node, options)
if (traverser.isBroken()) {
return
}
}
}
|
javascript
|
{
"resource": ""
}
|
q53411
|
traverseNodes
|
train
|
function traverseNodes(nodes, visitor) {
const ne = new NodeEventGenerator(visitor)
traverse(nodes, {
enter(child) {
ne.enterNode(child)
},
leave(child) {
ne.leaveNode(child)
},
})
}
|
javascript
|
{
"resource": ""
}
|
q53412
|
findToken
|
train
|
function findToken(node, test) {
let find = null
traverse(node, {
enter(child) {
if (test(child)) {
find = child
this.break()
}
},
})
return find
}
|
javascript
|
{
"resource": ""
}
|
q53413
|
inToken
|
train
|
function inToken(loc, token) {
if (typeof loc === "number") {
return token.range[0] <= loc && loc < token.range[1]
}
return locationInRangeLoc(loc, token.loc.start, token.loc.end)
}
|
javascript
|
{
"resource": ""
}
|
q53414
|
findExpressionStatement
|
train
|
function findExpressionStatement(start, end) {
let target = sourceCode.getNodeByRangeIndex(start)
while (
target &&
target.range[1] <= end &&
start <= target.range[0]
) {
if (
target.type === "ExpressionStatement" &&
start === target.range[0] &&
target.range[1] === end
) {
return target
}
target = target.parent
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q53415
|
equalsLocation
|
train
|
function equalsLocation(a, b) {
return a.range[0] === b.range[0] && a.range[1] === b.range[1]
}
|
javascript
|
{
"resource": ""
}
|
q53416
|
isLineStart
|
train
|
function isLineStart(loc) {
const actualText = getActualLineIndentText(loc.line)
return actualText.length === loc.column
}
|
javascript
|
{
"resource": ""
}
|
q53417
|
setOffsetToLoc
|
train
|
function setOffsetToLoc(loc, offset, baseline) {
if (baseline >= loc.line) {
return
}
const actualText = getActualLineIndentText(loc.line)
if (actualText.length !== loc.column) {
return
}
offsets.set(loc.line, {
actualText,
baseline,
offset,
expectedIndent: undefined,
})
}
|
javascript
|
{
"resource": ""
}
|
q53418
|
setOffsetToIndex
|
train
|
function setOffsetToIndex(startIndex, offset, baseline) {
const loc = sourceCode.getLocFromIndex(startIndex)
setOffsetToLoc(loc, offset, baseline)
}
|
javascript
|
{
"resource": ""
}
|
q53419
|
setOffsetToLine
|
train
|
function setOffsetToLine(line, offset, baseline) {
if (baseline >= line) {
return
}
const actualText = getActualLineIndentText(line)
offsets.set(line, {
actualText,
baseline,
offset,
expectedIndent: undefined,
})
}
|
javascript
|
{
"resource": ""
}
|
q53420
|
setOffsetRootToIndex
|
train
|
function setOffsetRootToIndex(startIndex) {
const loc = sourceCode.getLocFromIndex(startIndex)
if (!offsets.has(loc.line)) {
setOffsetToLoc(loc, 0, -1)
}
}
|
javascript
|
{
"resource": ""
}
|
q53421
|
isDummyElement
|
train
|
function isDummyElement(node) {
return (
!node.startTag &&
(node.name === "body" ||
node.name === "head" ||
node.name === "html")
)
}
|
javascript
|
{
"resource": ""
}
|
q53422
|
getStartToken
|
train
|
function getStartToken(elementNode) {
if (!elementNode) {
return null
}
if (elementNode.type !== "HTMLElement") {
return null
}
if (isDummyElement(elementNode)) {
return null
}
return elementNode.startTag || elementNode
}
|
javascript
|
{
"resource": ""
}
|
q53423
|
findIndentationStartPunctuator
|
train
|
function findIndentationStartPunctuator(evaluate) {
const searchIndex = evaluate.code.search(/(\S)\s*$/u)
if (searchIndex < 0) {
return null
}
const charIndex =
evaluate.expressionStart.range[1] + searchIndex
const node = sourceCode.getNodeByRangeIndex(charIndex)
if (!node) {
// comment only
return null
}
const tokens = sourceCode
.getTokens(node)
.filter(
t =>
t.range[0] <= evaluate.range[1] &&
t.range[1] >= evaluate.range[0]
)
let targetToken = tokens.find(
t => t.range[0] <= charIndex && charIndex < t.range[1]
)
if (!targetToken) {
targetToken = tokens
.reverse()
.find(t => t.range[1] <= charIndex)
}
let token = targetToken
while (token) {
if (
token.range[0] > evaluate.range[1] ||
token.range[1] < evaluate.range[0]
) {
return null
}
if (isIndentationStartPunctuator(token)) {
return token
}
if (isIndentationEndPunctuator(token)) {
// skip
const next = findPairOpenPunctuator(token)
token = sourceCode.getTokenBefore(next)
continue
}
token = sourceCode.getTokenBefore(token)
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q53424
|
findPairOpenPunctuator
|
train
|
function findPairOpenPunctuator(closeToken) {
const closePunctuatorText = closeToken.value
const isPairOpenPunctuator =
closePunctuatorText === ")"
? isLeftParen
: closePunctuatorText === "}"
? isLeftBrace
: isLeftBracket
let token = sourceCode.getTokenBefore(closeToken)
while (token) {
if (isPairOpenPunctuator(token)) {
return token
}
if (isIndentationEndPunctuator(token)) {
// skip
const next = findPairOpenPunctuator(token)
token = sourceCode.getTokenBefore(next)
continue
}
token = sourceCode.getTokenBefore(token)
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q53425
|
findPairClosePunctuator
|
train
|
function findPairClosePunctuator(openToken) {
const openPunctuatorText = openToken.value
const isPairClosePunctuator =
openPunctuatorText === "("
? isRightParen
: openPunctuatorText === "{"
? isRightBrace
: isRightBracket
let token = sourceCode.getTokenAfter(openToken)
while (token) {
if (isPairClosePunctuator(token)) {
return token
}
if (isIndentationStartPunctuator(token)) {
// skip
const next = findPairClosePunctuator(token)
token = sourceCode.getTokenAfter(next)
continue
}
token = sourceCode.getTokenAfter(token)
}
return null
}
|
javascript
|
{
"resource": ""
}
|
q53426
|
findSwitchCaseBodyInfoAtLineStart
|
train
|
function findSwitchCaseBodyInfoAtLineStart(line) {
const index = sourceCode.getIndexFromLoc({
line,
column: 0,
})
let switchCaseNode = sourceCode.getNodeByRangeIndex(index)
if (
!switchCaseNode ||
switchCaseNode.type === "SwitchStatement"
) {
switchCaseNode = switchStatementNode.cases.find(
(_token, i) => {
const next = switchStatementNode.cases[i + 1]
if (!next || index < next.range[0]) {
return true
}
return false
}
)
}
if (
!switchCaseNode ||
switchCaseNode.type !== "SwitchCase"
) {
// not SwitchCase
return null
}
if (switchCaseNode.test) {
if (index < switchCaseNode.test.range[1]) {
// not body
return null
}
} else {
// default:
const fToken = sourceCode.getFirstToken(switchCaseNode)
const colon = sourceCode.getTokenAfter(
fToken,
t => t.type === "Punctuator" && t.value === ":"
)
if (index < colon.range[1]) {
// not body
return null
}
}
if (
!equalsLocation(
switchCaseNode.parent,
switchStatementNode
)
) {
// not target
return null
}
const casesIndex = switchStatementNode.cases.findIndex(c =>
equalsLocation(c, switchCaseNode)
)
const evaluate = evaluates.find(
e =>
e.range[0] <= switchCaseNode.range[0] &&
switchCaseNode.range[0] < e.range[1]
)
return {
evaluate,
casesIndex,
node: switchCaseNode,
}
}
|
javascript
|
{
"resource": ""
}
|
q53427
|
inIgnore
|
train
|
function inIgnore(line) {
const index = sourceCode.getIndexFromLoc({
line,
column: 0,
})
return ignoreRanges.find(
range => range[0] <= index && index < range[1]
)
}
|
javascript
|
{
"resource": ""
}
|
q53428
|
equalLine
|
train
|
function equalLine(index1, index2) {
return (
sourceCode.getLocFromIndex(index1).line ===
sourceCode.getLocFromIndex(index2).line
)
}
|
javascript
|
{
"resource": ""
}
|
q53429
|
getDelimitersFinalMeans
|
train
|
function getDelimitersFinalMeans(text, innerCode) {
const codeStart = text.indexOf(innerCode)
const codeEnd = codeStart + innerCode.length
return [text.slice(0, codeStart), text.slice(codeEnd)]
}
|
javascript
|
{
"resource": ""
}
|
q53430
|
settingToRegExpInfo
|
train
|
function settingToRegExpInfo(val, defaultDelimiters) {
if (!val) {
return {
pattern: `${defaultDelimiters[0]}([\\s\\S]*?)${
defaultDelimiters[1]
}`,
getDelimiters: () => defaultDelimiters,
}
}
if (Array.isArray(val)) {
return {
pattern: `${escapeRegExp(val[0])}([\\s\\S]*?)${escapeRegExp(
val[1]
)}`,
getDelimiters: () => val,
}
}
const source = val instanceof RegExp ? val.source : `${val}`
const pattern =
source.indexOf("([\\s\\S]+?)") >= 0
? source.replace("([\\s\\S]+?)", "([\\s\\S]*?)")
: source.indexOf("([\\S\\s]+?)") >= 0
? source.replace("([\\S\\s]+?)", "([\\s\\S]*?)")
: source
let getDelimiters = undefined
const delmPattern = pattern.split("([\\s\\S]*?)")
if (delmPattern.length === 2) {
const re = new RegExp(
delmPattern.map(s => `(${s})`).join("([\\s\\S]*?)"),
"u"
)
getDelimiters = (text, innerCode) => {
const r = text.match(re)
if (r) {
return [r[1], r[3]]
}
return getDelimitersFinalMeans(text, innerCode)
}
} else {
getDelimiters = getDelimitersFinalMeans
}
return {
pattern,
getDelimiters,
}
}
|
javascript
|
{
"resource": ""
}
|
q53431
|
parseTemplate
|
train
|
function parseTemplate(code, parserOptions) {
const sourceCodeStore = new SourceCodeStore(code)
// 文字位置をそのままにしてscriptとhtmlを分解
let script = ""
let pre = 0
let template = ""
const microTemplateTokens = [] // テンプレートTokens
for (const token of genMicroTemplateTokens(
code,
parserOptions,
sourceCodeStore
)) {
microTemplateTokens.push(token)
const start = token.start
const end = token.end
const part = code.slice(pre, start)
script += replaceToWhitespace(part)
template += part
const scriptBeforeBase = token.expressionStart.chars
const scriptAfterBase = token.expressionEnd.chars
const scriptBefore = replaceToWhitespace(scriptBeforeBase)
let scriptAfter = replaceToWhitespace(scriptAfterBase)
if (token.type !== "MicroTemplateEvaluate") {
scriptAfter = scriptAfter.replace(/ /u, ";")
}
script += `${scriptBefore}${token.code}${scriptAfter}`
template += replaceToWhitespace(code.slice(start, end))
pre = end
}
const part = code.slice(pre, code.length)
script += replaceToWhitespace(part)
template += part
const scriptResult = parseScript(script, parserOptions)
sourceCodeStore.template = template
sourceCodeStore.script = script
const service = new MicroTemplateService({
code,
template,
script,
microTemplateTokens,
sourceCodeStore,
ast: scriptResult.ast,
})
container.addService(parserOptions.filePath, service)
scriptResult.services = Object.assign(scriptResult.services || {}, {
getMicroTemplateService() {
return service
},
})
return scriptResult
}
|
javascript
|
{
"resource": ""
}
|
q53432
|
parseScript
|
train
|
function parseScript(code, parserOptions) {
const parser =
parserOptions.parser === "espree" || !parserOptions.parser
? require("espree") // eslint-disable-line @mysticatea/node/no-extraneous-require
: require(parserOptions.parser)
const scriptParserOptions = Object.assign({}, parserOptions)
delete scriptParserOptions.parser
const result =
typeof parser.parseForESLint === "function"
? parser.parseForESLint(code, scriptParserOptions)
: parser.parse(code, scriptParserOptions)
if (result.ast) {
return result
}
return {
ast: result,
}
}
|
javascript
|
{
"resource": ""
}
|
q53433
|
isHtmlFile
|
train
|
function isHtmlFile(code, options) {
const filePath =
typeof options.filePath === "string" ? options.filePath : "unknown.js"
for (const ext of container.targetExtensions) {
if (filePath.endsWith(ext)) {
return true
}
}
if (filePath.endsWith(".vue")) {
return false
}
return /^\s*</u.test(code)
}
|
javascript
|
{
"resource": ""
}
|
q53434
|
parseForESLint
|
train
|
function parseForESLint(code, options) {
const opts = options || {}
if (!isHtmlFile(code, opts)) {
return parseScript(code, opts)
}
return parseTemplate(code, opts)
}
|
javascript
|
{
"resource": ""
}
|
q53435
|
getStartTagIgnoreTokens
|
train
|
function getStartTagIgnoreTokens(startTag) {
if (!skipAttrValues) {
return []
}
const tokens = []
for (const attr of startTag.attributes) {
tokens.push(attr.valueToken)
}
for (const attr of startTag.ignoredAttributes) {
tokens.push(attr.valueToken)
}
return tokens.filter(t => Boolean(t))
}
|
javascript
|
{
"resource": ""
}
|
q53436
|
checkForIrregularWhitespace
|
train
|
function checkForIrregularWhitespace(node, ignoreTokens) {
const text = sourceCode.text.slice(node.range[0], node.range[1])
let match = undefined
/**
* Check whether the index is in ignore location.
* @param {number} index The index.
* @returns {boolean} `true` if the index is in ignore location.
*/
function isIgnoreLocation(index) {
return (
ignoreTokens.find(
t => t.range[0] <= index && index < t.range[1]
) ||
templateTokens.find(
t => t.range[0] <= index && index < t.range[1]
)
)
}
while ((match = IRREGULAR_WHITESPACE.exec(text)) !== null) {
const index = node.range[0] + match.index
if (isIgnoreLocation(index)) {
continue
}
const code = `0000${sourceCode.text[index]
.charCodeAt(0)
.toString(16)}`
.slice(-4)
.toUpperCase()
context.report({
loc: sourceCode.getLocFromIndex(index),
messageId: "unexpected",
data: { code },
fix: defineWhitespaceFix(index),
})
}
while ((match = IRREGULAR_LINE_TERMINATORS.exec(text)) !== null) {
const index = node.range[0] + match.index
if (isIgnoreLocation(index)) {
continue
}
const code = `0000${sourceCode.text[index]
.charCodeAt(0)
.toString(16)}`
.slice(-4)
.toUpperCase()
context.report({
loc: sourceCode.getLocFromIndex(index),
messageId: "unexpected",
data: { code },
fix: defineLineTerminatorsFix(index),
})
}
}
|
javascript
|
{
"resource": ""
}
|
q53437
|
isIgnoreLocation
|
train
|
function isIgnoreLocation(index) {
return (
ignoreTokens.find(
t => t.range[0] <= index && index < t.range[1]
) ||
templateTokens.find(
t => t.range[0] <= index && index < t.range[1]
)
)
}
|
javascript
|
{
"resource": ""
}
|
q53438
|
collectRules
|
train
|
function collectRules(category) {
return rules.reduce((obj, rule) => {
if (!category || rule.meta.docs.category === category) {
obj[rule.meta.docs.ruleId] = "error"
}
return obj
}, {})
}
|
javascript
|
{
"resource": ""
}
|
q53439
|
buildChildTokens
|
train
|
function buildChildTokens(node, parentToken, html, sourceCodeStore, lastIndex) {
return node.childNodes.map(child => {
const token = parse5NodeToToken(
child,
parentToken,
html,
sourceCodeStore,
lastIndex
)
token.parent = parentToken
return token
})
}
|
javascript
|
{
"resource": ""
}
|
q53440
|
defineRootTokenBuilder
|
train
|
function defineRootTokenBuilder(Type) {
return (node, _parentToken, html, sourceCodeStore, lastIndex) => {
const token = new Type(html, 0, lastIndex, sourceCodeStore)
token.children = buildChildTokens(
node,
token,
html,
sourceCodeStore,
lastIndex
)
return token
}
}
|
javascript
|
{
"resource": ""
}
|
q53441
|
parse5NodeToToken
|
train
|
function parse5NodeToToken(
node,
parentToken,
html,
sourceCodeStore,
lastIndex
) {
const type = NODENAME_TO_TYPE_MAP[node.nodeName]
? NODENAME_TO_TYPE_MAP[node.nodeName]
: "HTMLElement"
return TOKEN_BUILDERS[type](
node,
parentToken,
html,
sourceCodeStore,
lastIndex
)
}
|
javascript
|
{
"resource": ""
}
|
q53442
|
parseHtml
|
train
|
function parseHtml(html, sourceCodeStore) {
const isFragment = !/^\s*<(!doctype|html|head|body|!--)/iu.test(html)
const document = (isFragment ? parse5.parseFragment : parse5.parse)(html, {
sourceCodeLocationInfo: true,
})
return parse5NodeToToken(document, null, html, sourceCodeStore, html.length)
}
|
javascript
|
{
"resource": ""
}
|
q53443
|
isSingleLine
|
train
|
function isSingleLine(node) {
return node.loc.start.line === node.loc.end.line
}
|
javascript
|
{
"resource": ""
}
|
q53444
|
report
|
train
|
function report(attributes) {
attributes.forEach((prop, i) => {
context.report({
node: prop,
loc: prop.loc,
messageId: "missingNewLine",
data: {
name: prop.key,
},
fix:
i === 0
? fixer => fixer.insertTextBefore(prop, "\n")
: undefined,
})
})
}
|
javascript
|
{
"resource": ""
}
|
q53445
|
groupAttrsByLine
|
train
|
function groupAttrsByLine(attributes) {
const propsPerLine = [[attributes[0]]]
attributes.reduce((previous, current) => {
if (previous.loc.end.line === current.loc.start.line) {
propsPerLine[propsPerLine.length - 1].push(current)
} else {
propsPerLine.push([current])
}
return current
})
return propsPerLine
}
|
javascript
|
{
"resource": ""
}
|
q53446
|
isMultiline
|
train
|
function isMultiline(node, contentFirstLoc, contentLastLoc) {
if (
node.startTag.loc.start.line !== node.startTag.loc.end.line ||
node.endTag.loc.start.line !== node.endTag.loc.end.line
) {
// multiline tag
return true
}
if (contentFirstLoc.line < contentLastLoc.line) {
// multiline contents
return true
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q53447
|
isIgnore
|
train
|
function isIgnore(node) {
let target = node
while (target.type === "HTMLElement") {
if (options.ignoreNames.indexOf(target.name) >= 0) {
// ignore element name
return true
}
target = target.parent
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q53448
|
getContentLocatuons
|
train
|
function getContentLocatuons(node) {
const contentStartIndex = node.startTag.range[1]
const contentEndIndex = node.endTag.range[0]
const contentText = sourceCode.text.slice(
contentStartIndex,
contentEndIndex
)
const contentFirstIndex = (() => {
const index = contentText.search(/\S/u)
if (index >= 0) {
return index + contentStartIndex
}
return contentEndIndex
})()
const contentLastIndex = (() => {
const index = contentText.search(/\S\s*$/gu)
if (index >= 0) {
return index + contentStartIndex + 1
}
return contentStartIndex
})()
return {
first: {
index: contentFirstIndex,
loc: sourceCode.getLocFromIndex(contentFirstIndex),
},
last: {
index: contentLastIndex,
loc: sourceCode.getLocFromIndex(contentLastIndex),
},
}
}
|
javascript
|
{
"resource": ""
}
|
q53449
|
traverseAst
|
train
|
function traverseAst(sourceCode, node, parent, visitor) {
if (visitor[node.type]) {
visitor[node.type](node, parent)
}
const keys = sourceCode.visitorKeys[node.type]
for (const key of keys) {
const child = node[key]
if (Array.isArray(child)) {
for (const c of child) {
if (c) {
traverseAst(sourceCode, c, node, visitor)
}
}
} else if (child) {
traverseAst(sourceCode, child, node, visitor)
}
}
}
|
javascript
|
{
"resource": ""
}
|
q53450
|
createBranchedHTML
|
train
|
function createBranchedHTML(service, branchStatements, targetNode) {
let template = service.template
const stripedRanges = []
/**
* Strip template of range.
* @param {number} start The start index of range.
* @param {number} end The end index of range.
* @returns {void}
*/
function strip(start, end) {
const before = template.slice(0, start)
const target = template.slice(start, end)
const after = template.slice(end)
template = before + target.replace(/\S/gu, " ") + after
stripedRanges.push([start, end])
}
const visitor = {
IfStatement(node) {
if (
node.alternate.range[0] <= targetNode.range[0] &&
targetNode.range[0] < node.alternate.range[1]
) {
strip(node.consequent.range[0], node.consequent.range[1])
} else {
strip(node.alternate.range[0], node.alternate.range[1])
}
},
SwitchStatement(node) {
let nodeCaseIndex = node.cases.findIndex((cur, index) => {
const next = node.cases[index + 1]
const endIndex = next ? next.range[0] : node.range[1]
return (
cur.range[0] <= targetNode.range[0] &&
targetNode.range[0] < endIndex
)
})
if (nodeCaseIndex < 0) {
nodeCaseIndex = 0
}
node.cases.forEach((cur, index) => {
if (index === nodeCaseIndex) {
return
}
const next = node.cases[index + 1]
const endIndex = next ? next.range[0] : node.range[1]
strip(cur.range[0], endIndex)
})
},
}
for (const node of branchStatements) {
visitor[node.type](node)
}
return new BranchedHTML(
template,
service.parseHtml(template),
stripedRanges
)
}
|
javascript
|
{
"resource": ""
}
|
q53451
|
strip
|
train
|
function strip(start, end) {
const before = template.slice(0, start)
const target = template.slice(start, end)
const after = template.slice(end)
template = before + target.replace(/\S/gu, " ") + after
stripedRanges.push([start, end])
}
|
javascript
|
{
"resource": ""
}
|
q53452
|
getTemplateTags
|
train
|
function getTemplateTags(start, end) {
const results = []
for (const token of microTemplateService.getMicroTemplateTokens()) {
if (token.range[1] <= start) {
continue
}
if (end <= token.range[0]) {
break
}
results.push(token)
}
return results
}
|
javascript
|
{
"resource": ""
}
|
q53453
|
validate
|
train
|
function validate(templateTags, attrs) {
const valueTokens = attrs
.map(attr => attr.valueToken)
.filter(t => Boolean(t))
for (const templateTag of templateTags) {
if (
valueTokens.some(
valueToken =>
valueToken.range[0] <= templateTag.range[0] &&
templateTag.range[1] <= valueToken.range[1]
)
) {
continue
}
const isInterpolate =
templateTag.type === "MicroTemplateInterpolate" ||
templateTag.type === "MicroTemplateEscape"
if (isInterpolate ? arrowInterpolateTag : arrowEvaluateTag) {
continue
}
context.report({
node: templateTag,
messageId: isInterpolate
? "unexpectedInterpolate"
: "unexpectedEvaluate",
})
}
}
|
javascript
|
{
"resource": ""
}
|
q53454
|
createARecord
|
train
|
function createARecord (domain, subdomain, ip, cb) {
var body = {
name: subdomain,
type: 'A',
content: ip
};
_hoverRequest('POST', '/domains/' + domain + '/dns', body, cb);
}
|
javascript
|
{
"resource": ""
}
|
q53455
|
createMXRecord
|
train
|
function createMXRecord (domain, subdomain, priority, ip, cb) {
var body = {
name: subdomain,
type: 'MX',
content: [priority, ip].join(' ')
};
_hoverRequest('POST', '/domains/' + domain + '/dns', body, cb);
}
|
javascript
|
{
"resource": ""
}
|
q53456
|
updateDomainDns
|
train
|
function updateDomainDns (dns, ip, cb) {
var body = {
content: ip
};
_hoverRequest('PUT', '/dns/' + dns, body, cb);
}
|
javascript
|
{
"resource": ""
}
|
q53457
|
_hoverRequest
|
train
|
function _hoverRequest (method, path, body, cb) {
// Check if previously logged in
if (_loggedin) return _hoverApiRequest(method, path, body, cb);
// Issue login request with provided username / password
r({
uri: baseUrl + '/login',
body: 'username=' + username + '&password=' + password,
headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
}, _rCallback(function (err) {
if (err) return cb(err);
// Note logged in / forward request
_loggedin = true;
_hoverApiRequest(method, path, body, cb);
}));
}
|
javascript
|
{
"resource": ""
}
|
q53458
|
_hoverApiRequest
|
train
|
function _hoverApiRequest (method, path, body, cb) {
// Check body provided
if (typeof body === 'function') {
cb = body;
body = null;
}
// Default options
var options = {
method: method,
uri: baseUrl + path
};
// Add body if provided
if (body) options.body = body;
// Issue request
r(options, _rCallback(function (err, data) {
if (err) return cb(err);
// Pull out property name
var key = _.without(_.keys(data), 'succeeded');
cb(null, data[key]);
}));
}
|
javascript
|
{
"resource": ""
}
|
q53459
|
_rCallback
|
train
|
function _rCallback (cb) {
return function (err, res, data) {
if (err) return cb(err);
if (!res || res.statusCode > 400) return cb(data);
cb(null, data);
};
}
|
javascript
|
{
"resource": ""
}
|
q53460
|
calcValueInfo
|
train
|
function calcValueInfo(valueToken) {
const text = valueToken.htmlValue
const firstChar = text[0]
const quote = firstChar === "'" || firstChar === '"' ? firstChar : undefined
const content = quote ? text.slice(1, -1) : text
return {
quote,
content,
}
}
|
javascript
|
{
"resource": ""
}
|
q53461
|
formatReportedCommentValue
|
train
|
function formatReportedCommentValue(token) {
const valueLines = token.value.split("\n")
const value = valueLines[0]
const formattedValue = `${value.slice(0, 12)}...`
return valueLines.length === 1 && value.length <= 12
? value
: formattedValue
}
|
javascript
|
{
"resource": ""
}
|
q53462
|
getTemplateTagByToken
|
train
|
function getTemplateTagByToken(token) {
return microTemplateService
.getMicroTemplateTokens()
.find(
t =>
t.expressionStart.range[1] <= token.range[0] &&
token.range[0] < t.expressionEnd.range[0]
)
}
|
javascript
|
{
"resource": ""
}
|
q53463
|
isIgnores
|
train
|
function isIgnores(leftToken, leftIndex, rightToken) {
const tokensAndComments = sourceCode.tokensAndComments
const leftTemplateTag = getTemplateTagByToken(leftToken)
const rightTemplateTag = getTemplateTagByToken(rightToken)
if (!leftTemplateTag || !rightTemplateTag) {
return true
}
// Ignore if token is the first token of the template tag script
if (
!sourceCode.text
.slice(
rightTemplateTag.expressionStart.range[1],
rightToken.range[0]
)
.trim()
) {
return true
}
// Ignore comments that are the last token on their line if `ignoreEOLComments` is active.
if (
ignoreEOLComments &&
isCommentToken(rightToken) &&
(leftIndex === tokensAndComments.length - 2 ||
rightToken.loc.end.line <
tokensAndComments[leftIndex + 2].loc.start.line)
) {
return true
}
// Ignore tokens that are in a node in the "exceptions" object
if (hasExceptions) {
const parentNode = sourceCode.getNodeByRangeIndex(
rightToken.range[0] - 1
)
if (parentNode && exceptions[parentNode.type]) {
return true
}
}
return false
}
|
javascript
|
{
"resource": ""
}
|
q53464
|
getEnabledRules
|
train
|
function getEnabledRules(allRules) {
return Object.keys(allRules).reduce((map, id) => {
if (allRules[id] === "error") {
map[id] = 2
}
return map
}, {})
}
|
javascript
|
{
"resource": ""
}
|
q53465
|
readRules
|
train
|
function readRules() {
const rulesRoot = path.resolve(__dirname, "../../lib/rules")
const result = fs.readdirSync(rulesRoot)
const rules = []
for (const name of result) {
const ruleName = name.replace(/\.js$/u, "")
const ruleId = `lodash-template/${ruleName}`
const rule = require(path.join(rulesRoot, name))
rule.meta.docs.ruleId = ruleId
rule.meta.docs.ruleName = ruleName
rules.push(rule)
}
return rules
}
|
javascript
|
{
"resource": ""
}
|
q53466
|
getCommentLocatuons
|
train
|
function getCommentLocatuons(node) {
const contentStartIndex = node.commentOpen.range[1]
const contentEndIndex = node.commentClose.range[0]
const contentText = sourceCode.text.slice(
contentStartIndex,
contentEndIndex
)
const contentFirstIndex = (() => {
const index = contentText.search(/\S/u)
if (index >= 0) {
return index + contentStartIndex
}
return contentEndIndex
})()
const contentLastIndex = (() => {
const index = contentText.search(/\S\s*$/gu)
if (index >= 0) {
return index + contentStartIndex + 1
}
return contentStartIndex
})()
return {
first: {
index: contentFirstIndex,
loc: sourceCode.getLocFromIndex(contentFirstIndex),
},
last: {
index: contentLastIndex,
loc: sourceCode.getLocFromIndex(contentLastIndex),
},
}
}
|
javascript
|
{
"resource": ""
}
|
q53467
|
startTagToTokens
|
train
|
function startTagToTokens(startTag) {
const tokens = [startTag.tagOpen]
for (const attr of startTag.attributes) {
tokens.push(attr)
}
tokens.push(startTag.tagClose)
return tokens
.filter(t => Boolean(t))
.sort((a, b) => a.range[0] - b.range[0])
}
|
javascript
|
{
"resource": ""
}
|
q53468
|
endTagToTokens
|
train
|
function endTagToTokens(endTag) {
const tokens = [endTag.tagOpen, endTag.tagClose]
return tokens
.filter(t => Boolean(t))
.sort((a, b) => a.range[0] - b.range[0])
}
|
javascript
|
{
"resource": ""
}
|
q53469
|
getIntersectionTemplateTags
|
train
|
function getIntersectionTemplateTags(start, end) {
return microTemplateService
.getMicroTemplateTokens()
.filter(
token =>
Math.max(start, token.range[0]) <=
Math.min(end, token.range[1])
)
.sort((a, b) => a.range[0] - b.range[0])
}
|
javascript
|
{
"resource": ""
}
|
q53470
|
processTokens
|
train
|
function processTokens(tokens) {
for (const tokenInfo of genTargetTokens(tokens)) {
const prevToken = tokenInfo.prevToken
const token = tokenInfo.token
const start = prevToken.range[1]
const end = token.range[0]
const spaces = end - start
if (
spaces > 1 &&
token.loc.start.line === prevToken.loc.start.line &&
!sourceCode.text.slice(start, end).trim()
) {
context.report({
node: token,
loc: {
start: prevToken.loc.end,
end: token.loc.start,
},
messageId: "unexpected",
fix: defineFix(start, end),
data: {
displayValue: formatReportedHTMLToken(token),
},
})
}
}
}
|
javascript
|
{
"resource": ""
}
|
q53471
|
formatReportedHTMLToken
|
train
|
function formatReportedHTMLToken(token) {
const valueLines = sourceCode.getText(token).split("\n")
const value = valueLines[0]
return value
}
|
javascript
|
{
"resource": ""
}
|
q53472
|
sortedLastIndexForNum
|
train
|
function sortedLastIndexForNum(array, value) {
let low = 0
let high = array == null ? low : array.length
while (low < high) {
const mid = (low + high) >>> 1
const computed = array[mid]
if (computed <= value) {
low = mid + 1
} else {
high = mid
}
}
return high
}
|
javascript
|
{
"resource": ""
}
|
q53473
|
init
|
train
|
function init() {
var stateFromHash = getStateFromHash();
var stateChanged = false;
if (typeof defaults === 'object' && defaults) {
Object.keys(defaults).forEach(function(key) {
if (key in stateFromHash) return;
stateFromHash[key] = defaults[key]
stateChanged = true;
});
}
if (stateChanged) set(stateFromHash);
}
|
javascript
|
{
"resource": ""
}
|
q53474
|
queryState
|
train
|
function queryState(defaults, options) {
options = options || {};
var history = options.history || windowHistory(defaults, options);
validateHistoryAPI(history);
history.onChanged(updateQuery)
var query = history.get() || Object.create(null);
var api = {
/**
* Gets current state.
*
* @param {string?} keyName if present then value for this key is returned.
* Otherwise the entire app state is returned.
*/
get: getValue,
/**
* Merges current app state with new key/value.
*
* @param {string} key name
* @param {string|number|date} value
*/
set: setValue,
/**
* Removes value from the query string
*/
unset: unsetValue,
/**
* Similar to `set()`, but only sets value if it was not set before.
*
* @param {string} key name
* @param {string|number|date} value
*/
setIfEmpty: setIfEmpty,
/**
* Releases all resources acquired by query state. After calling this method
* no hash monitoring will happen and no more events will be fired.
*/
dispose: dispose,
onChange: onChange,
offChange: offChange,
getHistoryObject: getHistoryObject,
}
var eventBus = eventify({});
return api;
function onChange(callback, ctx) {
eventBus.on('change', callback, ctx);
}
function offChange(callback, ctx) {
eventBus.off('change', callback, ctx)
}
function getHistoryObject() {
return history;
}
function dispose() {
// dispose all history listeners
history.dispose();
// And remove our own listeners
eventBus.off();
}
function getValue(keyName) {
if (keyName === undefined) return query;
return query[keyName];
}
function setValue(keyName, value) {
var keyNameType = typeof keyName;
if (keyNameType === 'object') {
Object.keys(keyName).forEach(function(key) {
query[key] = keyName[key];
});
} else if (keyNameType === 'string') {
query[keyName] = value;
}
history.set(query);
return api;
}
function unsetValue(keyName) {
if (!(keyName in query)) return; // nothing to do
delete query[keyName];
history.set(query);
return api;
}
function updateQuery(newAppState) {
query = newAppState;
eventBus.fire('change', query);
}
function setIfEmpty(keyName, value) {
if (typeof keyName === 'object') {
Object.keys(keyName).forEach(function(key) {
// TODO: Can I remove code duplication? The main reason why I don't
// want recursion here is to avoid spamming `history.set()`
if (key in query) return; // key name is not empty
query[key] = keyName[key];
});
}
if (keyName in query) return; // key name is not empty
query[keyName] = value;
history.set(query);
return api;
}
}
|
javascript
|
{
"resource": ""
}
|
q53475
|
instance
|
train
|
function instance(defaults, options) {
if (!singletonQS) {
singletonQS = queryState(defaults, options);
} else if (defaults) {
singletonQS.setIfEmpty(defaults);
}
return singletonQS;
}
|
javascript
|
{
"resource": ""
}
|
q53476
|
train
|
function(seq1, seq2, stepMap){
// get contrast arrays (src & target) by analyze step by step
var l1 = seq1.length,
l2 = seq2.length,
src = [], target = [];
for(var i = l1,j = l2; i > 0 || j > 0;){
switch(stepMap[i][j]){
case STEP_NOCHANGE:
src.unshift(seq1[i-1]);
target.unshift(MARK_SAME);
i -= 1;
j -= 1;
break;
case STEP_REPLACE:
src.unshift(seq1[i-1]);
target.unshift(seq2[j-1]);
i -= 1;
j -= 1;
break;
case STEP_REMOVE:
src.unshift(seq1[i-1]);
target.unshift(MARK_EMPTY);
i -= 1;
j -= 0;
break;
case STEP_INSERT:
src.unshift(MARK_EMPTY);
target.unshift(seq2[j-1]);
i -= 0;
j -= 1;
break;
}
}
return {
src: src,
target: target
};
}
|
javascript
|
{
"resource": ""
}
|
|
q53477
|
train
|
function(seq1, seq2, eq){
// do compare
var stepMap = coreCompare(seq1, seq2, eq);
// transform stepMap
var contrast = transformStepMap(seq1, seq2, stepMap),
src = contrast.src,
target = contrast.target;
// convert contrast arrays to edit script
var l = target.length,
start, len, to,
notEmpty = function(s){return s !== MARK_EMPTY;},
script = [],
i, j;
for(i = l - 1; i >= 0;){
// join continuous diffs
for(j = i; target[j] !== MARK_SAME && j >= 0; j--){}
if(j < i){
start = src.slice(0, j + 1).filter(notEmpty).length; // start pos of diffs (on src)
len = src.slice(j + 1, i + 1).filter(notEmpty).length; // length should be replaced (on src)
to = target.slice(j + 1, i + 1).filter(notEmpty); // new content
script.unshift(
to.length ?
[start, len, to] : // replace
[start, len] // remove
);
}
i = j - 1;
}
return script;
}
|
javascript
|
{
"resource": ""
}
|
|
q53478
|
decodeValue
|
train
|
function decodeValue(value) {
value = decodeURIComponent(value);
if (value === "") return value;
if (!isNaN(value)) return parseFloat(value);
if (isBolean(value)) return value === 'true';
if (isISODateString(value)) return new Date(value);
return value;
}
|
javascript
|
{
"resource": ""
}
|
q53479
|
train
|
function() {
var UITinymceService = function() {
var ID_ATTR = 'ui-tinymce';
// uniqueId keeps track of the latest assigned ID
var uniqueId = 0;
// getUniqueId returns a unique ID
var getUniqueId = function() {
uniqueId ++;
return ID_ATTR + '-' + uniqueId;
};
// return the function as a public method of the service
return {
getUniqueId: getUniqueId
};
};
// return a new instance of the service
return new UITinymceService();
}
|
javascript
|
{
"resource": ""
}
|
|
q53480
|
inspect
|
train
|
function inspect(val, router) {
if (ignoreResult || shouldContinue(val, router)) {
return iterate();
}
return next.cancel(val);
}
|
javascript
|
{
"resource": ""
}
|
q53481
|
train
|
function (navigationInstruction, callbackName, next, ignoreResult) {
var plan = navigationInstruction.plan;
var infos = findDeactivatable(plan, callbackName);
var i = infos.length; // query from inside out
function inspect(val) {
if (ignoreResult || shouldContinue(val)) {
return iterate();
}
return next.cancel(val);
}
function iterate() {
if (i--) {
try {
var viewModel = infos[i];
var result = viewModel[callbackName](navigationInstruction);
return processPotential(result, inspect, next.cancel);
}
catch (error) {
return next.cancel(error);
}
}
navigationInstruction.router.couldDeactivate = true;
return next();
}
return iterate();
}
|
javascript
|
{
"resource": ""
}
|
|
q53482
|
train
|
function (plan, callbackName, list) {
if (list === void 0) { list = []; }
for (var viewPortName in plan) {
var viewPortPlan = plan[viewPortName];
var prevComponent = viewPortPlan.prevComponent;
if ((viewPortPlan.strategy === activationStrategy.invokeLifecycle || viewPortPlan.strategy === activationStrategy.replace)
&& prevComponent) {
var viewModel = prevComponent.viewModel;
if (callbackName in viewModel) {
list.push(viewModel);
}
}
if (viewPortPlan.strategy === activationStrategy.replace && prevComponent) {
addPreviousDeactivatable(prevComponent, callbackName, list);
}
else if (viewPortPlan.childNavigationInstruction) {
findDeactivatable(viewPortPlan.childNavigationInstruction.plan, callbackName, list);
}
}
return list;
}
|
javascript
|
{
"resource": ""
}
|
|
q53483
|
train
|
function (routeLoader, navigationInstruction, config) {
var router = navigationInstruction.router;
var lifecycleArgs = navigationInstruction.lifecycleArgs;
return Promise.resolve()
.then(function () { return routeLoader.loadRoute(router, config, navigationInstruction); })
.then(
/**
* @param component an object carrying information about loaded route
* typically contains information about view model, childContainer, view and router
*/
function (component) {
var viewModel = component.viewModel, childContainer = component.childContainer;
component.router = router;
component.config = config;
if ('configureRouter' in viewModel) {
var childRouter_1 = childContainer.getChildRouter();
component.childRouter = childRouter_1;
return childRouter_1
.configure(function (c) { return viewModel.configureRouter(c, childRouter_1, lifecycleArgs[0], lifecycleArgs[1], lifecycleArgs[2]); })
.then(function () { return component; });
}
return component;
});
}
|
javascript
|
{
"resource": ""
}
|
|
q53484
|
train
|
function (success, fail, args, env) {
var result = new PluginResult(args, env);
result.ok(keyboard.getInstance().startService(), false);
}
|
javascript
|
{
"resource": ""
}
|
|
q53485
|
train
|
function (wgsLon, wgsLat) {
if (this.outOfChina(wgsLat, wgsLon))
return [wgsLon, wgsLat];
var d = this.delta(wgsLat, wgsLon);
return [wgsLon + d.lon, wgsLat + d.lat];
}
|
javascript
|
{
"resource": ""
}
|
|
q53486
|
train
|
function (gcjLon, gcjLat) {
if (this.outOfChina(gcjLat, gcjLon))
return [gcjLon, gcjLat];
var d = this.delta(gcjLat, gcjLon);
return [gcjLon - d.lon, gcjLat - d.lat];
}
|
javascript
|
{
"resource": ""
}
|
|
q53487
|
train
|
function (gcjLon, gcjLat) {
var initDelta = 0.01;
var threshold = 0.000000001;
var dLat = initDelta, dLon = initDelta;
var mLat = gcjLat - dLat, mLon = gcjLon - dLon;
var pLat = gcjLat + dLat, pLon = gcjLon + dLon;
var wgsLat, wgsLon, i = 0;
while (1) {
wgsLat = (mLat + pLat) / 2;
wgsLon = (mLon + pLon) / 2;
var tmp = this.gcj_encrypt(wgsLat, wgsLon)
dLat = tmp.lat - gcjLat;
dLon = tmp.lon - gcjLon;
if ((Math.abs(dLat) < threshold) && (Math.abs(dLon) < threshold))
break;
if (dLat > 0) pLat = wgsLat; else mLat = wgsLat;
if (dLon > 0) pLon = wgsLon; else mLon = wgsLon;
if (++i > 10000) break;
}
return [wgsLon, wgsLat];
}
|
javascript
|
{
"resource": ""
}
|
|
q53488
|
train
|
function (gcjLon, gcjLat) {
var x = gcjLon, y = gcjLat;
var z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * this.x_pi);
var theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * this.x_pi);
var bdLon = z * Math.cos(theta) + 0.0065;
var bdLat = z * Math.sin(theta) + 0.006;
return [bdLon, bdLat];
}
|
javascript
|
{
"resource": ""
}
|
|
q53489
|
train
|
function(source, fromCRS, toCRS) {
if (!source) {
return null;
}
if (!fromCRS || !toCRS) {
throw new Error('must provide a valid fromCRS and toCRS.');
}
if (this._isCoord(source)) {
return this._transformCoordinate(source, fromCRS, toCRS);
} else if (this._isArray(source)) {
var result = [];
for (var i = 0; i < source.length; i++) {
result.push(this.transform(source[i], fromCRS, toCRS));
}
return result;
}
return this._transformGeoJSON(source, fromCRS, toCRS);
}
|
javascript
|
{
"resource": ""
}
|
|
q53490
|
getTargetDOMElement
|
train
|
function getTargetDOMElement(binding, view) {
var target = binding.target;
// DOM element
if (target instanceof Element) {
return target;
}
// custom element or custom attribute
// tslint:disable-next-line:prefer-const
for (var i = 0, ii = view.controllers.length; i < ii; i++) {
var controller = view.controllers[i];
if (controller.viewModel === target) {
var element = controller.container.get(aureliaPal.DOM.Element);
if (element) {
return element;
}
throw new Error("Unable to locate target element for \"" + binding.sourceExpression + "\".");
}
}
throw new Error("Unable to locate target element for \"" + binding.sourceExpression + "\".");
}
|
javascript
|
{
"resource": ""
}
|
q53491
|
getPropertyInfo
|
train
|
function getPropertyInfo(expression, source) {
var originalExpression = expression;
while (expression instanceof aureliaBinding.BindingBehavior || expression instanceof aureliaBinding.ValueConverter) {
expression = expression.expression;
}
var object;
var propertyName;
if (expression instanceof aureliaBinding.AccessScope) {
object = aureliaBinding.getContextFor(expression.name, source, expression.ancestor);
propertyName = expression.name;
}
else if (expression instanceof aureliaBinding.AccessMember) {
object = getObject(originalExpression, expression.object, source);
propertyName = expression.name;
}
else if (expression instanceof aureliaBinding.AccessKeyed) {
object = getObject(originalExpression, expression.object, source);
propertyName = expression.key.evaluate(source);
}
else {
throw new Error("Expression '" + originalExpression + "' is not compatible with the validate binding-behavior.");
}
if (object === null || object === undefined) {
return null;
}
return { object: object, propertyName: propertyName };
}
|
javascript
|
{
"resource": ""
}
|
q53492
|
configure
|
train
|
function configure(
// tslint:disable-next-line:ban-types
frameworkConfig, callback) {
// the fluent rule definition API needs the parser to translate messages
// to interpolation expressions.
const messageParser = frameworkConfig.container.get(ValidationMessageParser);
const propertyParser = frameworkConfig.container.get(PropertyAccessorParser);
ValidationRules.initialize(messageParser, propertyParser);
// configure...
const config = new AureliaValidationConfiguration();
if (callback instanceof Function) {
callback(config);
}
config.apply(frameworkConfig.container);
// globalize the behaviors.
if (frameworkConfig.globalResources) {
frameworkConfig.globalResources(ValidateBindingBehavior, ValidateManuallyBindingBehavior, ValidateOnBlurBindingBehavior, ValidateOnChangeBindingBehavior, ValidateOnChangeOrBlurBindingBehavior, ValidationErrorsCustomAttribute, ValidationRendererCustomAttribute);
}
}
|
javascript
|
{
"resource": ""
}
|
q53493
|
applyBroadcast
|
train
|
function applyBroadcast () {
var args = Array.prototype.slice.call(arguments);
scope.$apply(function () {
scope.$emit.apply(scope, args);
});
}
|
javascript
|
{
"resource": ""
}
|
q53494
|
DigestStrategy
|
train
|
function DigestStrategy(options, secret, validate) {
if (typeof options == 'function') {
validate = secret;
secret = options;
options = {};
}
if (!secret) throw new Error('HTTP Digest authentication strategy requires a secret function');
passport.Strategy.call(this);
this.name = 'digest';
this._secret = secret;
this._validate = validate;
this._realm = options.realm || 'Users';
if (options.domain) {
this._domain = (Array.isArray(options.domain)) ? options.domain : [ options.domain ];
}
this._opaque = options.opaque;
this._algorithm = options.algorithm;
if (options.qop) {
this._qop = (Array.isArray(options.qop)) ? options.qop : [ options.qop ];
}
}
|
javascript
|
{
"resource": ""
}
|
q53495
|
parse
|
train
|
function parse(params) {
var opts = {};
var tokens = params.split(/,(?=(?:[^"]|"[^"]*")*$)/);
for (var i = 0, len = tokens.length; i < len; i++) {
var param = /(\w+)=["]?([^"]+)["]?$/.exec(tokens[i])
if (param) {
opts[param[1]] = param[2];
}
}
return opts;
}
|
javascript
|
{
"resource": ""
}
|
q53496
|
nonce
|
train
|
function nonce(len) {
var buf = []
, chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
, charlen = chars.length;
for (var i = 0; i < len; ++i) {
buf.push(chars[Math.random() * charlen | 0]);
}
return buf.join('');
}
|
javascript
|
{
"resource": ""
}
|
q53497
|
BasicStrategy
|
train
|
function BasicStrategy(options, verify) {
if (typeof options == 'function') {
verify = options;
options = {};
}
if (!verify) throw new Error('HTTP Basic authentication strategy requires a verify function');
passport.Strategy.call(this);
this.name = 'basic';
this._verify = verify;
this._realm = options.realm || 'Users';
this._passReqToCallback = options.passReqToCallback;
}
|
javascript
|
{
"resource": ""
}
|
q53498
|
scrollTo
|
train
|
function scrollTo(element, position, useTimeout) {
if (!angular.isDefined(position)) {
position = element;
element = window;
}
if (!angular.isArray(position)) {
position = [0, position];
}
// Prepare promise resolution
var deferred = $q.defer(), timeout;
var scrollOnceHandler = function () {
var check = (element === window) ?
[element.scrollX, element.scrollY] :
[element.scrollLeft, element.scrollTop];
if (check[0] != position[0] || check[1] != position[1]) {
return;
}
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
angular.element(element).off('scroll', scrollOnceHandler);
deferred.resolve();
$rootScope.$digest();
};
angular.element(element).on('scroll', scrollOnceHandler);
// Actual scrolling
if (element === window) {
element.scrollTo.apply(element, position);
}
else {
element.scrollLeft = position[0];
element.scrollTop = position[1];
}
// Backup resolver
if (useTimeout) timeout = setTimeout(function () {
angular.element(element).off('scroll', scrollOnceHandler);
var check = (element === window) ?
[element.scrollX, element.scrollY] :
[element.scrollLeft, element.scrollTop];
if (check[0] != position[0] || check[1] != position[1]) {
deferred.reject();
}
else {
deferred.resolve();
}
$rootScope.$digest();
}, 100);
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q53499
|
signalFromEvent
|
train
|
function signalFromEvent (target, event) {
return new QuickSignal(function (subscriber) {
var handler = function (e) {
subscriber(e);
};
var el = angular.element(target);
event.split(' ').map(function (e) {
el[0].addEventListener(e, handler, true);
});
subscriber.$dispose = function () {
event.split(' ').map(function (e) {
el[0].removeEventListener(e, handler, true);
});
};
});
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.