_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q16100
|
parseLanguages
|
train
|
function parseLanguages(book) {
var logger = book.getLogger();
return parseStructureFile(book, 'langs')
.spread(function(file, result) {
if (!file) {
return book;
}
var languages = Languages.createFromList(file, result);
logger.debug.ln('languages index file found at', file.getPath());
logger.info.ln('parsing multilingual book, with', languages.getList().size, 'languages');
return book.set('languages', languages);
});
}
|
javascript
|
{
"resource": ""
}
|
q16101
|
onFinish
|
train
|
function onFinish(output) {
var book = output.getBook();
var options = output.getOptions();
var prefix = options.get('prefix');
if (!book.isMultilingual()) {
return Promise(output);
}
var filePath = 'index.html';
var engine = createTemplateEngine(output, filePath);
var context = JSONUtils.encodeOutput(output);
// Render the theme
return Templating.renderFile(engine, prefix + '/languages.html', context)
// Write it to the disk
.then(function(tplOut) {
return writeFile(output, filePath, tplOut.getContent());
});
}
|
javascript
|
{
"resource": ""
}
|
q16102
|
generatePages
|
train
|
function generatePages(generator, output) {
var pages = output.getPages();
var logger = output.getLogger();
// Is generator ignoring assets?
if (!generator.onPage) {
return Promise(output);
}
return Promise.reduce(pages, function(out, page) {
var file = page.getFile();
logger.debug.ln('generate page "' + file.getPath() + '"');
return generatePage(out, page)
.then(function(resultPage) {
return generator.onPage(out, resultPage);
})
.fail(function(err) {
logger.error.ln('error while generating page "' + file.getPath() + '":');
throw err;
});
}, output);
}
|
javascript
|
{
"resource": ""
}
|
q16103
|
addPlugin
|
train
|
function addPlugin(config, pluginName, version) {
// For default plugin, we only ensure it is enabled
if (isDefaultPlugin(pluginName, version)) {
return togglePlugin(config, pluginName, true);
}
var deps = config.getPluginDependencies();
var dep = PluginDependency.create(pluginName, version);
deps = deps.push(dep);
return config.setPluginDependencies(deps);
}
|
javascript
|
{
"resource": ""
}
|
q16104
|
prepareAssets
|
train
|
function prepareAssets(output) {
var book = output.getBook();
var pages = output.getPages();
var logger = output.getLogger();
return Parse.listAssets(book, pages)
.then(function(assets) {
logger.info.ln('found', assets.size, 'asset files');
return output.set('assets', assets);
});
}
|
javascript
|
{
"resource": ""
}
|
q16105
|
encodeGlossary
|
train
|
function encodeGlossary(glossary) {
var file = glossary.getFile();
var entries = glossary.getEntries();
return {
file: encodeFile(file),
entries: entries
.map(encodeGlossaryEntry).toJS()
};
}
|
javascript
|
{
"resource": ""
}
|
q16106
|
measure
|
train
|
function measure(type, p) {
timers[type] = timers[type] || {
type: type,
count: 0,
total: 0,
min: undefined,
max: 0
};
var start = Date.now();
return p
.fin(function() {
var end = Date.now();
var duration = (end - start);
timers[type].count ++;
timers[type].total += duration;
if (is.undefined(timers[type].min)) {
timers[type].min = duration;
} else {
timers[type].min = Math.min(timers[type].min, duration);
}
timers[type].max = Math.max(timers[type].max, duration);
});
}
|
javascript
|
{
"resource": ""
}
|
q16107
|
dump
|
train
|
function dump(logger) {
var prefix = ' > ';
var measured = 0;
var totalDuration = Date.now() - startDate;
// Enable debug logging
var logLevel = logger.getLevel();
logger.setLevel('debug');
Immutable.Map(timers)
.valueSeq()
.sortBy(function(timer) {
measured += timer.total;
return timer.total;
})
.forEach(function(timer) {
var percent = (timer.total * 100) / totalDuration;
logger.debug.ln((percent.toFixed(1)) + '% of time spent in "' + timer.type + '" (' + timer.count + ' times) :');
logger.debug.ln(prefix + 'Total: ' + time(timer.total)+ ' | Average: ' + time(timer.total / timer.count));
logger.debug.ln(prefix + 'Min: ' + time(timer.min) + ' | Max: ' + time(timer.max));
logger.debug.ln('---------------------------');
});
logger.debug.ln(time(totalDuration - measured) + ' spent in non-mesured sections');
// Rollback to previous level
logger.setLevel(logLevel);
}
|
javascript
|
{
"resource": ""
}
|
q16108
|
loadPlugin
|
train
|
function loadPlugin(book, plugin) {
var logger = book.getLogger();
var name = plugin.getName();
var pkgPath = plugin.getPath();
// Try loading plugins from different location
var p = Promise()
.then(function() {
var packageContent;
var packageMain;
var content;
// Locate plugin and load package.json
try {
var res = resolve.sync('./package.json', { basedir: pkgPath });
pkgPath = path.dirname(res);
packageContent = require(res);
} catch (err) {
if (!isModuleNotFound(err)) throw err;
packageContent = undefined;
content = undefined;
return;
}
// Locate the main package
try {
var indexJs = path.normalize(packageContent.main || 'index.js');
packageMain = resolve.sync('./' + indexJs, { basedir: pkgPath });
} catch (err) {
if (!isModuleNotFound(err)) throw err;
packageMain = undefined;
}
// Load plugin JS content
if (packageMain) {
try {
content = require(packageMain);
} catch(err) {
throw new error.PluginError(err, {
plugin: name
});
}
}
// Update plugin
return plugin.merge({
'package': Immutable.fromJS(packageContent),
'content': Immutable.fromJS(content || {})
});
})
.then(validatePlugin);
p = timing.measure('plugin.load', p);
logger.info('loading plugin "' + name + '"... ');
return logger.info.promise(p);
}
|
javascript
|
{
"resource": ""
}
|
q16109
|
installPlugin
|
train
|
function installPlugin(book, plugin) {
var logger = book.getLogger();
var installFolder = book.getRoot();
var name = plugin.getName();
var requirement = plugin.getVersion();
logger.info.ln('');
logger.info.ln('installing plugin "' + name + '"');
// Find a version to install
return resolveVersion(plugin)
.then(function(version) {
if (!version) {
throw new Error('Found no satisfactory version for plugin "' + name + '" with requirement "' + requirement + '"');
}
logger.info.ln('install plugin "' + name +'" (' + requirement + ') from NPM with version', version);
return Promise.nfcall(npmi, {
'name': plugin.getNpmID(),
'version': version,
'path': installFolder,
'npmLoad': {
'loglevel': 'silent',
'loaded': true,
'prefix': installFolder
}
});
})
.then(function() {
logger.info.ok('plugin "' + name + '" installed with success');
});
}
|
javascript
|
{
"resource": ""
}
|
q16110
|
encodeSummary
|
train
|
function encodeSummary(output, summary) {
var result = {
/**
Iterate over the summary, it stops when the "iter" returns false
@param {Function} iter
*/
walk: function (iter) {
summary.getArticle(function(article) {
var jsonArticle = encodeSummaryArticle(article, false);
return iter(jsonArticle);
});
},
/**
Get an article by its level
@param {String} level
@return {Object}
*/
getArticleByLevel: function(level) {
var article = summary.getByLevel(level);
return (article? encodeSummaryArticle(article) : undefined);
},
/**
Get an article by its path
@param {String} level
@return {Object}
*/
getArticleByPath: function(level) {
var article = summary.getByPath(level);
return (article? encodeSummaryArticle(article) : undefined);
}
};
return result;
}
|
javascript
|
{
"resource": ""
}
|
q16111
|
train
|
function (iter) {
summary.getArticle(function(article) {
var jsonArticle = encodeSummaryArticle(article, false);
return iter(jsonArticle);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q16112
|
indexLevels
|
train
|
function indexLevels(summary) {
var parts = summary.getParts();
parts = parts.map(indexPartLevels);
return summary.set('parts', parts);
}
|
javascript
|
{
"resource": ""
}
|
q16113
|
extractKwargs
|
train
|
function extractKwargs(args) {
var last = args[args.length - 1];
return (is.object(last) && last.__keywords)? args.pop() : {};
}
|
javascript
|
{
"resource": ""
}
|
q16114
|
encodePage
|
train
|
function encodePage(page, summary) {
var file = page.getFile();
var attributes = page.getAttributes();
var article = summary.getByPath(file.getPath());
var result = attributes.toJS();
if (article) {
result.title = article.getTitle();
result.level = article.getLevel();
result.depth = article.getDepth();
var nextArticle = summary.getNextArticle(article);
if (nextArticle) {
result.next = encodeSummaryArticle(nextArticle);
}
var prevArticle = summary.getPrevArticle(article);
if (prevArticle) {
result.previous = encodeSummaryArticle(prevArticle);
}
}
result.content = page.getContent();
result.dir = page.getDir();
return result;
}
|
javascript
|
{
"resource": ""
}
|
q16115
|
findInstalled
|
train
|
function findInstalled(folder) {
var options = {
dev: false,
log: function() {},
depth: 4
};
var results = Immutable.OrderedMap();
function onPackage(pkg, parent) {
if (!pkg.name) return;
var name = pkg.name;
var version = pkg.version;
var pkgPath = pkg.realPath;
var depth = pkg.depth;
var dependencies = pkg.dependencies;
var pluginName = name.slice(PREFIX.length);
if (!validateId(name)){
if (parent) return;
} else {
results = results.set(pluginName, Plugin({
name: pluginName,
version: version,
path: pkgPath,
depth: depth,
parent: parent
}));
}
Immutable.Map(dependencies).forEach(function(dep) {
onPackage(dep, pluginName);
});
}
// Search for gitbook-plugins in node_modules folder
var node_modules = path.join(folder, 'node_modules');
// List all folders in node_modules
return fs.readdir(node_modules)
.fail(function() {
return Promise([]);
})
.then(function(modules) {
return Promise.serie(modules, function(module) {
// Not a gitbook-plugin
if (!validateId(module)) {
return Promise();
}
// Read gitbook-plugin package details
var module_folder = path.join(node_modules, module);
return Promise.nfcall(readInstalled, module_folder, options)
.then(function(data) {
onPackage(data);
});
});
})
.then(function() {
// Return installed plugins
return results;
});
}
|
javascript
|
{
"resource": ""
}
|
q16116
|
encodePage
|
train
|
function encodePage(output, page) {
var book = output.getBook();
var summary = book.getSummary();
var fs = book.getContentFS();
var file = page.getFile();
// JS Page is based on the JSON output
var result = JSONUtils.encodePage(page, summary);
result.type = file.getType();
result.path = file.getPath();
result.rawPath = fs.resolve(result.path);
deprecate.field(output, 'page.progress', result, 'progress', function() {
return encodeProgress(output, page);
}, '"page.progress" property is deprecated');
deprecate.field(output, 'page.sections', result, 'sections', [
{
content: result.content,
type: 'normal'
}
], '"sections" property is deprecated, use page.content instead');
return result;
}
|
javascript
|
{
"resource": ""
}
|
q16117
|
logNotice
|
train
|
function logNotice(book, key, message) {
if (logged[key] || disabled[key]) return;
logged[key] = true;
var logger = book.getLogger();
logger.warn.ln(message);
}
|
javascript
|
{
"resource": ""
}
|
q16118
|
deprecateMethod
|
train
|
function deprecateMethod(book, key, fn, msg) {
return function() {
logNotice(book, key, msg);
return fn.apply(this, arguments);
};
}
|
javascript
|
{
"resource": ""
}
|
q16119
|
deprecateField
|
train
|
function deprecateField(book, key, instance, property, value, msg) {
var store = undefined;
var prepare = function() {
if (!is.undefined(store)) return;
if (is.fn(value)) store = value();
else store = value;
};
var getter = function(){
prepare();
logNotice(book, key, msg);
return store;
};
var setter = function(v) {
prepare();
logNotice(book, key, msg);
store = v;
return store;
};
Object.defineProperty(instance, property, {
get: getter,
set: setter,
enumerable: true,
configurable: true
});
}
|
javascript
|
{
"resource": ""
}
|
q16120
|
deprecateRenamedMethod
|
train
|
function deprecateRenamedMethod(book, key, instance, oldName, newName, msg) {
msg = msg || ('"' + oldName + '" is deprecated, use "' + newName + '()" instead');
var fn = objectPath.get(instance, newName);
instance[oldName] = deprecateMethod(book, key, fn, msg);
}
|
javascript
|
{
"resource": ""
}
|
q16121
|
modifyHTML
|
train
|
function modifyHTML(page, operations) {
var html = page.getContent();
var $ = cheerio.load(html);
return Promise.forEach(operations, function(op) {
return op($);
})
.then(function() {
var resultHTML = $.html();
return page.set('content', resultHTML);
});
}
|
javascript
|
{
"resource": ""
}
|
q16122
|
validateConfig
|
train
|
function validateConfig(bookJson) {
var v = new jsonschema.Validator();
var result = v.validate(bookJson, schema, {
propertyName: 'config'
});
// Throw error
if (result.errors.length > 0) {
throw new error.ConfigurationError(new Error(result.errors[0].stack));
}
// Insert default values
var defaults = jsonSchemaDefaults(schema);
return mergeDefaults(bookJson, defaults);
}
|
javascript
|
{
"resource": ""
}
|
q16123
|
locateRootFolder
|
train
|
function locateRootFolder() {
var firstDefaultPlugin = DEFAULT_PLUGINS.first();
var pluginPath = resolve.sync(firstDefaultPlugin.getNpmID() + '/package.json', {
basedir: __dirname
});
var nodeModules = path.resolve(pluginPath, '../../..');
return nodeModules;
}
|
javascript
|
{
"resource": ""
}
|
q16124
|
generateBook
|
train
|
function generateBook(generator, book, options) {
options = generator.Options(options);
var state = generator.State? generator.State({}) : Immutable.Map();
var start = Date.now();
return Promise(
new Output({
book: book,
options: options,
state: state,
generator: generator.name
})
)
// Cleanup output folder
.then(function(output) {
var logger = output.getLogger();
var rootFolder = output.getRoot();
logger.debug.ln('cleanup folder "' + rootFolder + '"');
return fs.ensureFolder(rootFolder)
.thenResolve(output);
})
.then(processOutput.bind(null, generator))
// Log duration and end message
.then(function(output) {
var logger = output.getLogger();
var end = Date.now();
var duration = (end - start)/1000;
logger.info.ok('generation finished with success in ' + duration.toFixed(1) + 's !');
return output;
});
}
|
javascript
|
{
"resource": ""
}
|
q16125
|
encodeConfig
|
train
|
function encodeConfig(output, config) {
var result = {
values: config.getValues().toJS(),
get: function(key, defaultValue) {
return objectPath.get(result.values, key, defaultValue);
},
set: function(key, value) {
return objectPath.set(result.values, key, value);
}
};
deprecate.field(output, 'config.options', result, 'options',
result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
deprecate.field(output, 'config.options.generator', result.values, 'generator',
output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead');
deprecate.field(output, 'config.options.generator', result.values, 'output',
output.getRoot(), '"options.output" property is deprecated, use "output.root()" instead');
return result;
}
|
javascript
|
{
"resource": ""
}
|
q16126
|
getPluginConfig
|
train
|
function getPluginConfig(config, pluginName) {
var pluginsConfig = config.getValues().get('pluginsConfig');
if (pluginsConfig === undefined) {
return {};
}
var pluginConf = pluginsConfig.get(pluginName);
if (pluginConf === undefined) {
return {};
} else {
return pluginConf.toJS();
}
}
|
javascript
|
{
"resource": ""
}
|
q16127
|
encodeLanguages
|
train
|
function encodeLanguages(languages) {
var file = languages.getFile();
var list = languages.getList();
return {
file: encodeFile(file),
list: list
.valueSeq()
.map(function(lang) {
return {
id: lang.getID(),
title: lang.getTitle()
};
}).toJS()
};
}
|
javascript
|
{
"resource": ""
}
|
q16128
|
createFromDependency
|
train
|
function createFromDependency(pluginName) {
var npmID = PluginDependency.nameToNpmID(pluginName);
var version = pkg.dependencies[npmID];
return PluginDependency.create(pluginName, version);
}
|
javascript
|
{
"resource": ""
}
|
q16129
|
parseFile
|
train
|
function parseFile(fs, file, type) {
var filepath = file.getPath();
var parser = file.getParser();
if (!parser) {
return Promise.reject(
error.FileNotParsableError({
filename: filepath
})
);
}
return fs.readAsString(filepath)
.then(function(content) {
if (type === 'readme') {
return parser.parseReadme(content);
} else if (type === 'glossary') {
return parser.parseGlossary(content);
} else if (type === 'summary') {
return parser.parseSummary(content);
} else if (type === 'langs') {
return parser.parseLanguages(content);
} else {
throw new Error('Parsing invalid type "' + type + '"');
}
})
.then(function(result) {
return [
file,
result
];
});
}
|
javascript
|
{
"resource": ""
}
|
q16130
|
listFilters
|
train
|
function listFilters(plugins) {
return plugins
.reverse()
.reduce(function(result, plugin) {
return result.merge(plugin.getFilters());
}, Immutable.Map());
}
|
javascript
|
{
"resource": ""
}
|
q16131
|
preparePlugins
|
train
|
function preparePlugins(output) {
var book = output.getBook();
return Promise()
// Only load plugins for main book
.then(function() {
if (book.isLanguageBook()) {
return output.getPlugins();
} else {
return Plugins.loadForBook(book);
}
})
// Update book's configuration using the plugins
.then(function(plugins) {
return Plugins.validateConfig(book, plugins)
.then(function(newBook) {
return output.merge({
book: newBook,
plugins: plugins
});
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16132
|
encodeSummary
|
train
|
function encodeSummary(summary) {
var file = summary.getFile();
var parts = summary.getParts();
return {
file: encodeFile(file),
parts: parts.map(encodeSummaryPart).toJS()
};
}
|
javascript
|
{
"resource": ""
}
|
q16133
|
indexArticleLevels
|
train
|
function indexArticleLevels(article, baseLevel) {
baseLevel = baseLevel || article.getLevel();
var articles = article.getArticles();
articles = articles.map(function(inner, i) {
return indexArticleLevels(inner, baseLevel + '.' + (i + 1));
});
return article.merge({
level: baseLevel,
articles: articles
});
}
|
javascript
|
{
"resource": ""
}
|
q16134
|
callHook
|
train
|
function callHook(name, getArgument, handleResult, output) {
getArgument = getArgument || defaultGetArgument;
handleResult = handleResult || defaultHandleResult;
var logger = output.getLogger();
var plugins = output.getPlugins();
logger.debug.ln('calling hook "' + name + '"');
// Create the JS context for plugins
var context = Api.encodeGlobal(output);
return timing.measure(
'call.hook.' + name,
// Get the arguments
Promise(getArgument(output))
// Call the hooks in serie
.then(function(arg) {
return Promise.reduce(plugins, function(prev, plugin) {
var hook = plugin.getHook(name);
if (!hook) {
return prev;
}
return hook.call(context, prev);
}, arg);
})
// Handle final result
.then(function(result) {
output = Api.decodeGlobal(output, context);
return handleResult(output, result);
})
);
}
|
javascript
|
{
"resource": ""
}
|
q16135
|
redirect
|
train
|
function redirect() {
var resultURL = urlTransform(req.url, function(parsed) {
parsed.pathname += '/';
return parsed;
});
res.statusCode = 301;
res.setHeader('Location', resultURL);
res.end('Redirecting to ' + resultURL);
}
|
javascript
|
{
"resource": ""
}
|
q16136
|
editArticleInList
|
train
|
function editArticleInList(articles, level, newArticle) {
return articles.map(function(article) {
var articleLevel = article.getLevel();
if (articleLevel === level) {
// it is the article to edit
return article.merge(newArticle);
} else if (level.indexOf(articleLevel) === 0) {
// it is a parent
var articles = editArticleInList(article.getArticles(), level, newArticle);
return article.set('articles', articles);
} else {
// This is not the article you are looking for
return article;
}
});
}
|
javascript
|
{
"resource": ""
}
|
q16137
|
editArticleInPart
|
train
|
function editArticleInPart(part, level, newArticle) {
var articles = part.getArticles();
articles = editArticleInList(articles, level, newArticle);
return part.set('articles', articles);
}
|
javascript
|
{
"resource": ""
}
|
q16138
|
mergeAtLevel
|
train
|
function mergeAtLevel(summary, level, newValue) {
var levelParts = level.split('.');
var partIndex = Number(levelParts[0]) -1;
var parts = summary.getParts();
var part = parts.get(partIndex);
if (!part) {
return summary;
}
var isEditingPart = levelParts.length < 2;
if (isEditingPart) {
part = part.merge(newValue);
} else {
part = editArticleInPart(part, level, newValue);
}
parts = parts.set(partIndex, part);
return summary.set('parts', parts);
}
|
javascript
|
{
"resource": ""
}
|
q16139
|
isExternal
|
train
|
function isExternal(href) {
try {
return Boolean(url.parse(href).protocol) && !isDataURI(href);
} catch(err) {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q16140
|
isAnchor
|
train
|
function isAnchor(href) {
try {
var parsed = url.parse(href);
return !!(!parsed.protocol && !parsed.path && parsed.hash);
} catch(err) {
return false;
}
}
|
javascript
|
{
"resource": ""
}
|
q16141
|
toAbsolute
|
train
|
function toAbsolute(_href, dir, outdir) {
if (isExternal(_href) || isDataURI(_href)) {
return _href;
}
outdir = outdir == undefined? dir : outdir;
_href = normalize(_href);
dir = normalize(dir);
outdir = normalize(outdir);
// Path "_href" inside the base folder
var hrefInRoot = normalize(path.join(dir, _href));
if (_href[0] == '/') {
hrefInRoot = normalize(_href.slice(1));
}
// Make it relative to output
_href = path.relative(outdir, hrefInRoot);
// Normalize windows paths
_href = normalize(_href);
return _href;
}
|
javascript
|
{
"resource": ""
}
|
q16142
|
parsePageFromString
|
train
|
function parsePageFromString(page, content) {
// Parse page YAML
var parsed = fm(content);
return page.merge({
content: parsed.body,
attributes: Immutable.fromJS(parsed.attributes),
dir: direction(parsed.body)
});
}
|
javascript
|
{
"resource": ""
}
|
q16143
|
onFinish
|
train
|
function onFinish(output) {
var book = output.getBook();
var outputRoot = output.getRoot();
if (!book.isMultilingual()) {
return Promise(output);
}
// Get main language
var languages = book.getLanguages();
var mainLanguage = languages.getDefaultLanguage();
// Read the main JSON
return fs.readFile(path.resolve(outputRoot, mainLanguage.getID(), 'README.json'), 'utf8')
// Extend the JSON
.then(function(content) {
var json = JSON.parse(content);
json.languages = JSONUtils.encodeLanguages(languages);
return json;
})
.then(function(json) {
return fs.writeFile(
path.resolve(outputRoot, 'README.json'),
JSON.stringify(json, null, 4)
);
})
.thenResolve(output);
}
|
javascript
|
{
"resource": ""
}
|
q16144
|
removeArticle
|
train
|
function removeArticle(summary, level) {
// Coerce to level
level = is.string(level)? level : level.getLevel();
var parent = summary.getParent(level);
var articles = parent.getArticles();
// Find the index to remove
var index = articles.findIndex(function(art) {
return art.getLevel() === level;
});
if (index === -1) {
return summary;
}
// Remove from children
articles = articles.remove(index);
parent = parent.set('articles', articles);
// Reindex the level from here
parent = indexArticleLevels(parent);
return mergeAtLevel(summary, parent.getLevel(), parent);
}
|
javascript
|
{
"resource": ""
}
|
q16145
|
editPartTitle
|
train
|
function editPartTitle(summary, index, newTitle) {
var parts = summary.getParts();
var part = parts.get(index);
if (!part) {
return summary;
}
part = part.set('title', newTitle);
parts = parts.set(index, part);
return summary.set('parts', parts);
}
|
javascript
|
{
"resource": ""
}
|
q16146
|
preparePages
|
train
|
function preparePages(output) {
var book = output.getBook();
var logger = book.getLogger();
if (book.isMultilingual()) {
return Promise(output);
}
return Parse.parsePagesList(book)
.then(function(pages) {
logger.info.ln('found', pages.size, 'pages');
return output.set('pages', pages);
});
}
|
javascript
|
{
"resource": ""
}
|
q16147
|
svgToPng
|
train
|
function svgToPng(rootFolder, currentFile, $) {
var currentDirectory = path.dirname(currentFile);
return editHTMLElement($, 'img', function($img) {
var src = $img.attr('src');
if (path.extname(src) !== '.svg') {
return;
}
// Calcul absolute path for this
src = LocationUtils.toAbsolute(src, currentDirectory, '.');
// We avoid generating twice the same PNG
var hash = crc.crc32(src).toString(16);
var fileName = hash + '.png';
// Input file path
var inputPath = path.join(rootFolder, src);
// Result file path
var filePath = path.join(rootFolder, fileName);
return fs.assertFile(filePath, function() {
return imagesUtil.convertSVGToPNG(inputPath, filePath);
})
.then(function() {
// Convert filename to a relative filename
fileName = LocationUtils.relative(currentDirectory, fileName);
// Replace src
$img.attr('src', fileName);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16148
|
installPlugins
|
train
|
function installPlugins(book) {
var logger = book.getLogger();
var config = book.getConfig();
var plugins = config.getPluginDependencies();
// Remove default plugins
// (only if version is same as installed)
plugins = plugins.filterNot(function(plugin) {
var dependency = DEFAULT_PLUGINS.find(function(dep) {
return dep.getName() === plugin.getName();
});
return (
// Disabled plugin
!plugin.isEnabled() ||
// Or default one installed in GitBook itself
(dependency &&
plugin.getVersion() === dependency.getVersion())
);
});
if (plugins.size == 0) {
logger.info.ln('nothing to install!');
return Promise();
}
logger.info.ln('installing', plugins.size, 'plugins using npm@' + npmi.NPM_VERSION);
return Promise.forEach(plugins, function(plugin) {
return installPlugin(book, plugin);
})
.thenResolve(plugins.size);
}
|
javascript
|
{
"resource": ""
}
|
q16149
|
removePlugin
|
train
|
function removePlugin(config, pluginName) {
var deps = config.getPluginDependencies();
// For default plugin, we have to disable it instead of removing from the list
if (isDefaultPlugin(pluginName)) {
return togglePlugin(config, pluginName, false);
}
// Remove the dependency from the list
deps = deps.filterNot(function(dep) {
return dep.getName() === pluginName;
});
return config.setPluginDependencies(deps);
}
|
javascript
|
{
"resource": ""
}
|
q16150
|
decodePage
|
train
|
function decodePage(output, page, result) {
var originalContent = page.getContent();
// No returned value
// Existing content will be used
if (!result) {
return page;
}
deprecate.disable('page.sections');
// GitBook 3
// Use returned page.content if different from original content
if (result.content != originalContent) {
page = page.set('content', result.content);
}
// GitBook 2 compatibility
// Finally, use page.sections
else if (result.sections) {
page = page.set('content',
result.sections.map(function(section) {
return section.content;
}).join('\n')
);
}
deprecate.enable('page.sections');
return page;
}
|
javascript
|
{
"resource": ""
}
|
q16151
|
spawnCmd
|
train
|
function spawnCmd(command, args, options) {
var d = Promise.defer();
var child = spawn(command, args, options);
child.on('error', function(error) {
return d.reject(error);
});
child.stdout.on('data', function (data) {
d.notify(data);
});
child.stderr.on('data', function (data) {
d.notify(data);
});
child.on('close', function(code) {
if (code === 0) {
d.resolve();
} else {
d.reject(new Error('Error with command "'+command+'"'));
}
});
return d.promise;
}
|
javascript
|
{
"resource": ""
}
|
q16152
|
escapeShellArg
|
train
|
function escapeShellArg(value) {
if (is.number(value)) {
return value;
}
value = String(value);
value = value.replace(/"/g, '\\"');
return '"' + value + '"';
}
|
javascript
|
{
"resource": ""
}
|
q16153
|
optionsToShellArgs
|
train
|
function optionsToShellArgs(options) {
var result = [];
for (var key in options) {
var value = options[key];
if (value === null || value === undefined || value === false) {
continue;
}
if (is.bool(value)) {
result.push(key);
} else {
result.push(key + '=' + escapeShellArg(value));
}
}
return result.join(' ');
}
|
javascript
|
{
"resource": ""
}
|
q16154
|
onInit
|
train
|
function onInit(output) {
return Promise(output)
.then(prepareI18n)
.then(prepareResources)
.then(copyPluginAssets);
}
|
javascript
|
{
"resource": ""
}
|
q16155
|
callPageHook
|
train
|
function callPageHook(name, output, page) {
return callHook(
name,
function(out) {
return Api.encodePage(out, page);
},
function(out, result) {
return Api.decodePage(out, page, result);
},
output
);
}
|
javascript
|
{
"resource": ""
}
|
q16156
|
reducedObject
|
train
|
function reducedObject(defaultVersion, currentVersion) {
if(defaultVersion === undefined) {
return currentVersion;
}
return currentVersion.reduce(function(result, value, key) {
var defaultValue = defaultVersion.get(key);
if (Immutable.Map.isMap(value)) {
var diffs = reducedObject(defaultValue, value);
if (diffs.size > 0) {
return result.set(key, diffs);
}
}
if (Immutable.is(defaultValue, value)) {
return result;
}
return result.set(key, value);
}, Immutable.Map());
}
|
javascript
|
{
"resource": ""
}
|
q16157
|
ensureRelative
|
train
|
function ensureRelative(outputDir, p) {
if (path.isAbsolute(p)) {
return path.relative(outputDir, p);
} else {
return p;
}
}
|
javascript
|
{
"resource": ""
}
|
q16158
|
get
|
train
|
function get(arr, n) {
return n >= 0 ? arr[n] : arr[arr.length + n];
}
|
javascript
|
{
"resource": ""
}
|
q16159
|
selectLanguage
|
train
|
function selectLanguage(options, lang) {
let langToUse = lang;
if (langToUse === '' && options.defaultLanguageForUnspecified !== undefined) {
langToUse = options.defaultLanguageForUnspecified;
}
let prismLang = loadPrismLang(langToUse);
if (prismLang === undefined && options.defaultLanguageForUnknown !== undefined) {
langToUse = options.defaultLanguageForUnknown;
prismLang = loadPrismLang(langToUse);
}
return [langToUse, prismLang];
}
|
javascript
|
{
"resource": ""
}
|
q16160
|
checkLanguageOption
|
train
|
function checkLanguageOption(options, optionName) {
const language = options[optionName];
if (language !== undefined && loadPrismLang(language) === undefined) {
throw new Error(`Bad option ${optionName}: There is no Prism language '${language}'.`);
}
}
|
javascript
|
{
"resource": ""
}
|
q16161
|
applyClass
|
train
|
function applyClass(token) {
// init attributes
token.attrs = token.attrs || [];
// get index of class attribute
let keys = token.attrs.map(arr => arr[0]);
let idx = keys.indexOf('class');
if (idx === -1) {
// Add class attribute if not defined
token.attrs.push(['class', className]);
} else {
// Get the current class list to append.
// Watch out for duplicates
let classStr = token.attrs[idx][1] || '';
let classList = classStr.split(' ');
// Add the class if we don't already have it
if (classList.indexOf(className) === -1) {
token.attrs[idx][1] = classStr += ' ' + className;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q16162
|
attachSearch
|
train
|
function attachSearch(ref) {
if (ref && window)
import('docsearch.js').then(({ default: docsearch }) => {
docsearch({
apiKey: '00f98b765b687b91399288e7c4c68ce1',
indexName: 'react_bootstrap_v4',
inputSelector: `#${ref.id}`,
debug: process.env.NODE_ENV !== 'production', // Set debug to true if you want to inspect the dropdown
});
});
}
|
javascript
|
{
"resource": ""
}
|
q16163
|
map
|
train
|
function map(children, func) {
let index = 0;
return React.Children.map(children, child =>
React.isValidElement(child) ? func(child, index++) : child,
);
}
|
javascript
|
{
"resource": ""
}
|
q16164
|
forEach
|
train
|
function forEach(children, func) {
let index = 0;
React.Children.forEach(children, child => {
if (React.isValidElement(child)) func(child, index++);
});
}
|
javascript
|
{
"resource": ""
}
|
q16165
|
convolve
|
train
|
function convolve(context, kernel) {
const canvas = context.canvas;
const width = canvas.width;
const height = canvas.height;
const size = Math.sqrt(kernel.length);
const half = Math.floor(size / 2);
const inputData = context.getImageData(0, 0, width, height).data;
const output = context.createImageData(width, height);
const outputData = output.data;
for (let pixelY = 0; pixelY < height; ++pixelY) {
const pixelsAbove = pixelY * width;
for (let pixelX = 0; pixelX < width; ++pixelX) {
let r = 0, g = 0, b = 0, a = 0;
for (let kernelY = 0; kernelY < size; ++kernelY) {
for (let kernelX = 0; kernelX < size; ++kernelX) {
const weight = kernel[kernelY * size + kernelX];
const neighborY = Math.min(
height - 1, Math.max(0, pixelY + kernelY - half));
const neighborX = Math.min(
width - 1, Math.max(0, pixelX + kernelX - half));
const inputIndex = (neighborY * width + neighborX) * 4;
r += inputData[inputIndex] * weight;
g += inputData[inputIndex + 1] * weight;
b += inputData[inputIndex + 2] * weight;
a += inputData[inputIndex + 3] * weight;
}
}
const outputIndex = (pixelsAbove + pixelX) * 4;
outputData[outputIndex] = r;
outputData[outputIndex + 1] = g;
outputData[outputIndex + 2] = b;
outputData[outputIndex + 3] = kernel.normalized ? a : 255;
}
}
context.putImageData(output, 0, 0);
}
|
javascript
|
{
"resource": ""
}
|
q16166
|
rgb2hcl
|
train
|
function rgb2hcl(pixel) {
const red = rgb2xyz(pixel[0]);
const green = rgb2xyz(pixel[1]);
const blue = rgb2xyz(pixel[2]);
const x = xyz2lab(
(0.4124564 * red + 0.3575761 * green + 0.1804375 * blue) / Xn);
const y = xyz2lab(
(0.2126729 * red + 0.7151522 * green + 0.0721750 * blue) / Yn);
const z = xyz2lab(
(0.0193339 * red + 0.1191920 * green + 0.9503041 * blue) / Zn);
const l = 116 * y - 16;
const a = 500 * (x - y);
const b = 200 * (y - z);
const c = Math.sqrt(a * a + b * b);
let h = Math.atan2(b, a);
if (h < 0) {
h += twoPi;
}
pixel[0] = h;
pixel[1] = c;
pixel[2] = l;
return pixel;
}
|
javascript
|
{
"resource": ""
}
|
q16167
|
hcl2rgb
|
train
|
function hcl2rgb(pixel) {
const h = pixel[0];
const c = pixel[1];
const l = pixel[2];
const a = Math.cos(h) * c;
const b = Math.sin(h) * c;
let y = (l + 16) / 116;
let x = isNaN(a) ? y : y + a / 500;
let z = isNaN(b) ? y : y - b / 200;
y = Yn * lab2xyz(y);
x = Xn * lab2xyz(x);
z = Zn * lab2xyz(z);
pixel[0] = xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z);
pixel[1] = xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z);
pixel[2] = xyz2rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z);
return pixel;
}
|
javascript
|
{
"resource": ""
}
|
q16168
|
createWordIndex
|
train
|
function createWordIndex(exampleData) {
const index = {};
const keys = ['shortdesc', 'title', 'tags'];
exampleData.forEach((data, i) => {
keys.forEach(key => {
let text = data[key];
if (Array.isArray(text)) {
text = text.join(' ');
}
const words = text ? text.split(/\W+/) : [];
words.forEach(word => {
if (word) {
word = word.toLowerCase();
let counts = index[word];
if (counts) {
if (index in counts) {
counts[i] += 1;
} else {
counts[i] = 1;
}
} else {
counts = {};
counts[i] = 1;
index[word] = counts;
}
}
});
});
});
return index;
}
|
javascript
|
{
"resource": ""
}
|
q16169
|
getJsSource
|
train
|
function getJsSource(chunk, jsName) {
let jsSource;
for (let i = 0, ii = chunk.modules.length; i < ii; ++i) {
const module = chunk.modules[i];
if (module.modules) {
jsSource = getJsSource(module, jsName);
if (jsSource) {
return jsSource;
}
}
if (module.identifier.endsWith(jsName) && module.source) {
return module.source;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q16170
|
getDependencies
|
train
|
function getDependencies(jsSource) {
const lines = jsSource.split('\n');
const dependencies = {
ol: pkg.version
};
for (let i = 0, ii = lines.length; i < ii; ++i) {
const line = lines[i];
const importMatch = line.match(importRegEx);
if (importMatch) {
const imp = importMatch[1];
if (!imp.startsWith('ol/') && imp != 'ol') {
const parts = imp.split('/');
let dep;
if (imp.startsWith('@')) {
dep = parts.slice(0, 2).join('/');
} else {
dep = parts[0];
}
if (dep in pkg.devDependencies) {
dependencies[dep] = pkg.devDependencies[dep];
}
}
}
}
return dependencies;
}
|
javascript
|
{
"resource": ""
}
|
q16171
|
setCommonGeometryProperties
|
train
|
function setCommonGeometryProperties(multiGeometry, geometries) {
const ii = geometries.length;
const extrudes = new Array(geometries.length);
const tessellates = new Array(geometries.length);
const altitudeModes = new Array(geometries.length);
let hasExtrude, hasTessellate, hasAltitudeMode;
hasExtrude = hasTessellate = hasAltitudeMode = false;
for (let i = 0; i < ii; ++i) {
const geometry = geometries[i];
extrudes[i] = geometry.get('extrude');
tessellates[i] = geometry.get('tessellate');
altitudeModes[i] = geometry.get('altitudeMode');
hasExtrude = hasExtrude || extrudes[i] !== undefined;
hasTessellate = hasTessellate || tessellates[i] !== undefined;
hasAltitudeMode = hasAltitudeMode || altitudeModes[i];
}
if (hasExtrude) {
multiGeometry.set('extrude', extrudes);
}
if (hasTessellate) {
multiGeometry.set('tessellate', tessellates);
}
if (hasAltitudeMode) {
multiGeometry.set('altitudeMode', altitudeModes);
}
}
|
javascript
|
{
"resource": ""
}
|
q16172
|
msPointerDown
|
train
|
function msPointerDown(inEvent) {
this.pointerMap[inEvent.pointerId.toString()] = inEvent;
const e = this.prepareEvent_(inEvent);
this.dispatcher.down(e, inEvent);
}
|
javascript
|
{
"resource": ""
}
|
q16173
|
msPointerUp
|
train
|
function msPointerUp(inEvent) {
const e = this.prepareEvent_(inEvent);
this.dispatcher.up(e, inEvent);
this.cleanup(inEvent.pointerId);
}
|
javascript
|
{
"resource": ""
}
|
q16174
|
msPointerCancel
|
train
|
function msPointerCancel(inEvent) {
const e = this.prepareEvent_(inEvent);
this.dispatcher.cancel(e, inEvent);
this.cleanup(inEvent.pointerId);
}
|
javascript
|
{
"resource": ""
}
|
q16175
|
msLostPointerCapture
|
train
|
function msLostPointerCapture(inEvent) {
const e = this.dispatcher.makeEvent('lostpointercapture', inEvent, inEvent);
this.dispatcher.dispatchEvent(e);
}
|
javascript
|
{
"resource": ""
}
|
q16176
|
msGotPointerCapture
|
train
|
function msGotPointerCapture(inEvent) {
const e = this.dispatcher.makeEvent('gotpointercapture', inEvent, inEvent);
this.dispatcher.dispatchEvent(e);
}
|
javascript
|
{
"resource": ""
}
|
q16177
|
adaptAttributions
|
train
|
function adaptAttributions(attributionLike) {
if (!attributionLike) {
return null;
}
if (Array.isArray(attributionLike)) {
return function(frameState) {
return attributionLike;
};
}
if (typeof attributionLike === 'function') {
return attributionLike;
}
return function(frameState) {
return [attributionLike];
};
}
|
javascript
|
{
"resource": ""
}
|
q16178
|
train
|
function(evt) {
if (evt.dragging) {
return;
}
/** @type {string} */
let helpMsg = 'Click to start drawing';
if (sketch) {
const geom = sketch.getGeometry();
if (geom instanceof Polygon) {
helpMsg = continuePolygonMsg;
} else if (geom instanceof LineString) {
helpMsg = continueLineMsg;
}
}
helpTooltipElement.innerHTML = helpMsg;
helpTooltip.setPosition(evt.coordinate);
helpTooltipElement.classList.remove('hidden');
}
|
javascript
|
{
"resource": ""
}
|
|
q16179
|
train
|
function(line) {
const length = getLength(line);
let output;
if (length > 100) {
output = (Math.round(length / 1000 * 100) / 100) +
' ' + 'km';
} else {
output = (Math.round(length * 100) / 100) +
' ' + 'm';
}
return output;
}
|
javascript
|
{
"resource": ""
}
|
|
q16180
|
train
|
function(polygon) {
const area = getArea(polygon);
let output;
if (area > 10000) {
output = (Math.round(area / 1000000 * 100) / 100) +
' ' + 'km<sup>2</sup>';
} else {
output = (Math.round(area * 100) / 100) +
' ' + 'm<sup>2</sup>';
}
return output;
}
|
javascript
|
{
"resource": ""
}
|
|
q16181
|
createHelpTooltip
|
train
|
function createHelpTooltip() {
if (helpTooltipElement) {
helpTooltipElement.parentNode.removeChild(helpTooltipElement);
}
helpTooltipElement = document.createElement('div');
helpTooltipElement.className = 'ol-tooltip hidden';
helpTooltip = new Overlay({
element: helpTooltipElement,
offset: [15, 0],
positioning: 'center-left'
});
map.addOverlay(helpTooltip);
}
|
javascript
|
{
"resource": ""
}
|
q16182
|
createMeasureTooltip
|
train
|
function createMeasureTooltip() {
if (measureTooltipElement) {
measureTooltipElement.parentNode.removeChild(measureTooltipElement);
}
measureTooltipElement = document.createElement('div');
measureTooltipElement.className = 'ol-tooltip ol-tooltip-measure';
measureTooltip = new Overlay({
element: measureTooltipElement,
offset: [0, -15],
positioning: 'bottom-center'
});
map.addOverlay(measureTooltip);
}
|
javascript
|
{
"resource": ""
}
|
q16183
|
getAreaInternal
|
train
|
function getAreaInternal(coordinates, radius) {
let area = 0;
const len = coordinates.length;
let x1 = coordinates[len - 1][0];
let y1 = coordinates[len - 1][1];
for (let i = 0; i < len; i++) {
const x2 = coordinates[i][0];
const y2 = coordinates[i][1];
area += toRadians(x2 - x1) *
(2 + Math.sin(toRadians(y1)) +
Math.sin(toRadians(y2)));
x1 = x2;
y1 = y2;
}
return area * radius * radius / 2.0;
}
|
javascript
|
{
"resource": ""
}
|
q16184
|
DECtoSEX
|
train
|
function DECtoSEX(angle) {
// Extract DMS
const deg = parseInt(angle, 10);
const min = parseInt((angle - deg) * 60, 10);
const sec = (((angle - deg) * 60) - min) * 60;
// Result in degrees sex (dd.mmss)
return deg + min / 100 + sec / 10000;
}
|
javascript
|
{
"resource": ""
}
|
q16185
|
DEGtoSEC
|
train
|
function DEGtoSEC(angle) {
// Extract DMS
const deg = parseInt(angle, 10);
let min = parseInt((angle - deg) * 100, 10);
let sec = (((angle - deg) * 100) - min) * 100;
// Avoid rounding problems with seconds=0
const parts = String(angle).split('.');
if (parts.length == 2 && parts[1].length == 2) {
min = Number(parts[1]);
sec = 0;
}
// Result in degrees sex (dd.mmss)
return sec + min * 60 + deg * 3600;
}
|
javascript
|
{
"resource": ""
}
|
q16186
|
getListenerMap
|
train
|
function getListenerMap(target, opt_create) {
let listenerMap = target.ol_lm;
if (!listenerMap && opt_create) {
listenerMap = target.ol_lm = {};
}
return listenerMap;
}
|
javascript
|
{
"resource": ""
}
|
q16187
|
removeListeners
|
train
|
function removeListeners(target, type) {
const listeners = getListeners(target, type);
if (listeners) {
for (let i = 0, ii = listeners.length; i < ii; ++i) {
/** @type {import("./events/Target.js").default} */ (target).
removeEventListener(type, listeners[i].boundListener);
clear(listeners[i]);
}
listeners.length = 0;
const listenerMap = getListenerMap(target);
if (listenerMap) {
delete listenerMap[type];
if (Object.keys(listenerMap).length === 0) {
removeListenerMap(target);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q16188
|
getImageData
|
train
|
function getImageData(layer, frameState, layerState) {
const renderer = layer.getRenderer();
if (!renderer) {
throw new Error('Unsupported layer type: ' + layer);
}
if (!renderer.prepareFrame(frameState, layerState)) {
return null;
}
const width = frameState.size[0];
const height = frameState.size[1];
const element = renderer.renderFrame(frameState, layerState);
if (!(element instanceof HTMLCanvasElement)) {
throw new Error('Unsupported rendered element: ' + element);
}
if (element.width === width && element.height === height) {
const context = element.getContext('2d');
return context.getImageData(0, 0, width, height);
}
if (!sharedContext) {
sharedContext = createCanvasContext2D(width, height);
} else {
const canvas = sharedContext.canvas;
if (canvas.width !== width || canvas.height !== height) {
sharedContext = createCanvasContext2D(width, height);
} else {
sharedContext.clearRect(0, 0, width, height);
}
}
sharedContext.drawImage(element, 0, 0, width, height);
return sharedContext.getImageData(0, 0, width, height);
}
|
javascript
|
{
"resource": ""
}
|
q16189
|
createLayers
|
train
|
function createLayers(sources) {
const len = sources.length;
const layers = new Array(len);
for (let i = 0; i < len; ++i) {
layers[i] = createLayer(sources[i]);
}
return layers;
}
|
javascript
|
{
"resource": ""
}
|
q16190
|
createLayer
|
train
|
function createLayer(layerOrSource) {
// @type {import("../layer/Layer.js").default}
let layer;
if (layerOrSource instanceof Source) {
if (layerOrSource instanceof TileSource) {
layer = new TileLayer({source: layerOrSource});
} else if (layerOrSource instanceof ImageSource) {
layer = new ImageLayer({source: layerOrSource});
}
} else {
layer = layerOrSource;
}
return layer;
}
|
javascript
|
{
"resource": ""
}
|
q16191
|
fillCircleArrayRowToMiddle
|
train
|
function fillCircleArrayRowToMiddle(array, x, y) {
let i;
const radius = Math.floor(array.length / 2);
if (x >= radius) {
for (i = radius; i < x; i++) {
array[i][y] = true;
}
} else if (x < radius) {
for (i = x + 1; i < radius; i++) {
array[i][y] = true;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q16192
|
concatenateArcs
|
train
|
function concatenateArcs(indices, arcs) {
/** @type {Array<import("../coordinate.js").Coordinate>} */
const coordinates = [];
let index, arc;
for (let i = 0, ii = indices.length; i < ii; ++i) {
index = indices[i];
if (i > 0) {
// splicing together arcs, discard last point
coordinates.pop();
}
if (index >= 0) {
// forward arc
arc = arcs[index];
} else {
// reverse arc
arc = arcs[~index].slice().reverse();
}
coordinates.push.apply(coordinates, arc);
}
// provide fresh copies of coordinate arrays
for (let j = 0, jj = coordinates.length; j < jj; ++j) {
coordinates[j] = coordinates[j].slice();
}
return coordinates;
}
|
javascript
|
{
"resource": ""
}
|
q16193
|
readPointGeometry
|
train
|
function readPointGeometry(object, scale, translate) {
const coordinates = object['coordinates'];
if (scale && translate) {
transformVertex(coordinates, scale, translate);
}
return new Point(coordinates);
}
|
javascript
|
{
"resource": ""
}
|
q16194
|
readMultiPointGeometry
|
train
|
function readMultiPointGeometry(object, scale, translate) {
const coordinates = object['coordinates'];
if (scale && translate) {
for (let i = 0, ii = coordinates.length; i < ii; ++i) {
transformVertex(coordinates[i], scale, translate);
}
}
return new MultiPoint(coordinates);
}
|
javascript
|
{
"resource": ""
}
|
q16195
|
readMultiLineStringGeometry
|
train
|
function readMultiLineStringGeometry(object, arcs) {
const coordinates = [];
for (let i = 0, ii = object['arcs'].length; i < ii; ++i) {
coordinates[i] = concatenateArcs(object['arcs'][i], arcs);
}
return new MultiLineString(coordinates);
}
|
javascript
|
{
"resource": ""
}
|
q16196
|
readPolygonGeometry
|
train
|
function readPolygonGeometry(object, arcs) {
const coordinates = [];
for (let i = 0, ii = object['arcs'].length; i < ii; ++i) {
coordinates[i] = concatenateArcs(object['arcs'][i], arcs);
}
return new Polygon(coordinates);
}
|
javascript
|
{
"resource": ""
}
|
q16197
|
readMultiPolygonGeometry
|
train
|
function readMultiPolygonGeometry(object, arcs) {
const coordinates = [];
for (let i = 0, ii = object['arcs'].length; i < ii; ++i) {
// for each polygon
const polyArray = object['arcs'][i];
const ringCoords = [];
for (let j = 0, jj = polyArray.length; j < jj; ++j) {
// for each ring
ringCoords[j] = concatenateArcs(polyArray[j], arcs);
}
coordinates[i] = ringCoords;
}
return new MultiPolygon(coordinates);
}
|
javascript
|
{
"resource": ""
}
|
q16198
|
readFeaturesFromGeometryCollection
|
train
|
function readFeaturesFromGeometryCollection(collection, arcs, scale, translate, property, name, opt_options) {
const geometries = collection['geometries'];
const features = [];
for (let i = 0, ii = geometries.length; i < ii; ++i) {
features[i] = readFeatureFromGeometry(
geometries[i], arcs, scale, translate, property, name, opt_options);
}
return features;
}
|
javascript
|
{
"resource": ""
}
|
q16199
|
readFeatureFromGeometry
|
train
|
function readFeatureFromGeometry(object, arcs, scale, translate, property, name, opt_options) {
let geometry;
const type = object.type;
const geometryReader = GEOMETRY_READERS[type];
if ((type === 'Point') || (type === 'MultiPoint')) {
geometry = geometryReader(object, scale, translate);
} else {
geometry = geometryReader(object, arcs);
}
const feature = new Feature();
feature.setGeometry(transformGeometryWithOptions(geometry, false, opt_options));
if (object.id !== undefined) {
feature.setId(object.id);
}
let properties = object.properties;
if (property) {
if (!properties) {
properties = {};
}
properties[property] = name;
}
if (properties) {
feature.setProperties(properties, true);
}
return feature;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.