text stringlengths 1 2.83M | id stringlengths 16 152 | metadata dict | __index_level_0__ int64 0 949 |
|---|---|---|---|
const REGEXP_WHITESPACE = /\s/;
function getDynamicImportStartAndEnd(str: string, codeStart: number) {
let start = -1;
let end = -1;
for (let i = 0; i < str.length; i += 1) {
const isWhitespace = REGEXP_WHITESPACE.test(str[i]);
if (start === -1) {
if (!isWhitespace) {
start = i;
}
}
if (isWhitespace) {
if (end === -1) {
// we hit the end of a word, set the previous index as the last
end = i - 1;
}
} else if (i === str.length - 1) {
// we are at the end of the string
if (end === -1) {
end = i;
}
} else {
// we're in a word or we hit a new word
end = -1;
}
}
return { dynamicStart: codeStart + start, dynamicEnd: codeStart + end + 1 };
}
export function parseDynamicImport(code: string, start: number, end: number) {
const rawDynamicImport = code.substring(start, end);
const { dynamicStart, dynamicEnd } = getDynamicImportStartAndEnd(rawDynamicImport, start);
const importString = code.substring(dynamicStart, dynamicEnd);
const importSpecifier = importString.substring(1, importString.length - 1);
const startSymbol = code[dynamicStart];
const stringLiteral = [`\``, "'", '"'].includes(startSymbol);
const concatenatedString =
startSymbol === `\`` || importSpecifier.includes("'") || importSpecifier.includes('"');
return {
importString,
importSpecifier: stringLiteral ? importSpecifier : importString,
stringLiteral,
concatenatedString,
dynamicStart,
dynamicEnd,
};
}
| modernweb-dev/web/packages/dev-server-core/src/plugins/parseDynamicImport.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-core/src/plugins/parseDynamicImport.ts",
"repo_id": "modernweb-dev",
"token_count": 594
} | 180 |
<p>Hello world</p>
| modernweb-dev/web/packages/dev-server-core/test/fixtures/basic/html-fragment-b.html/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-core/test/fixtures/basic/html-fragment-b.html",
"repo_id": "modernweb-dev",
"token_count": 9
} | 181 |
import { expect } from 'chai';
import path from 'path';
import { createTestServer } from '../helpers.js';
describe('serveFilesMiddleware', () => {
it('can serve files outside of the root directory', async () => {
const { host, server } = await createTestServer({
plugins: [{ name: 'test' }],
rootDir: path.resolve(
__dirname,
'..',
'fixtures',
'outside-root-dir',
'packages',
'package-a',
),
});
try {
const response = await fetch(`${host}/__wds-outside-root__/2/node_modules/foo/index.js`);
const responseText = await response.text();
expect(response.status).to.equal(200);
expect(responseText).to.include("export default 'foo'");
} finally {
server.stop();
}
});
});
| modernweb-dev/web/packages/dev-server-core/test/middleware/serveFilesMiddleware.test.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-core/test/middleware/serveFilesMiddleware.test.ts",
"repo_id": "modernweb-dev",
"token_count": 323
} | 182 |
{
"name": "dev-server-esbuild-demo",
"version": "1.0.0",
"license": "ISC",
"scripts": {
"start": "wds --node-resolve --open --watch"
},
"devDependencies": {
"@web/dev-server": "^0.1.30"
}
}
| modernweb-dev/web/packages/dev-server-esbuild/demo/ts/package.json/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-esbuild/demo/ts/package.json",
"repo_id": "modernweb-dev",
"token_count": 100
} | 183 |
/**
* Based on: https://github.com/Polymer/lit-element/pull/802
*/
const implMap = new Map();
function isHotReloadableElementClass(maybe) {
return 'hotReplaceCallback' in maybe;
}
const originalDefine = customElements.define;
function hotDefine(tagname, classObj) {
if (!('hotReplaceCallback' in classObj)) {
return originalDefine.call(customElements, tagname, classObj);
}
const impl = implMap.get(tagname);
if (!impl) {
implMap.set(tagname, classObj);
originalDefine.call(customElements, tagname, classObj);
} else {
impl.hotReplaceCallback(classObj);
}
}
customElements.define = hotDefine;
| modernweb-dev/web/packages/dev-server-hmr/demo/lit-html/hot-elements/patch-custom-element.js/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-hmr/demo/lit-html/hot-elements/patch-custom-element.js",
"repo_id": "modernweb-dev",
"token_count": 218
} | 184 |
export { hmrPlugin } from './hmrPluginFactory.js';
| modernweb-dev/web/packages/dev-server-hmr/src/index.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-hmr/src/index.ts",
"repo_id": "modernweb-dev",
"token_count": 17
} | 185 |
<html>
<head>
<script type="importmap">
{
"imports": {
"../src/postData.js": "./mocks/postData.js"
}
}
</script>
</head>
<body>
<script type="module">
import { runTests } from '@web/test-runner-mocha';
import { expect } from '@esm-bundle/chai';
import { sendMessage } from '../src/sendMessage.js';
import { postData, __postDataSpy, __importMeta } from '../src/postData.js';
runTests(() => {
describe('sendMessage()', () => {
beforeEach(() => {
__postDataSpy.reset();
});
it('serves a mocked module', () => {
expect(new URL(__importMeta.url).pathname).to.equal(
'/packages/dev-server-import-maps/test-browser/test/mocks/postData.js',
);
});
it('calls postData with message a', async () => {
await sendMessage('a');
expect(__postDataSpy.callCount).to.equal(1);
expect(__postDataSpy.getCall(0).args).to.eql(['message', { message: 'a' }]);
});
it('calls postData with message b', async () => {
await sendMessage('b');
expect(__postDataSpy.callCount).to.equal(1);
expect(__postDataSpy.getCall(0).args).to.eql(['message', { message: 'b' }]);
});
});
});
</script>
</body>
</html>
| modernweb-dev/web/packages/dev-server-import-maps/test-browser/test/import-map-a.test.html/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-import-maps/test-browser/test/import-map-a.test.html",
"repo_id": "modernweb-dev",
"token_count": 683
} | 186 |
import { transformAsync, TransformOptions } from '@babel/core';
export const es5Config: TransformOptions = {
caller: {
name: '@web/dev-server-legacy',
supportsStaticESM: true,
},
sourceType: 'module',
babelrc: false,
configFile: false,
presets: [
[
require.resolve('@babel/preset-env'),
{
targets: ['defaults', 'ie 10'],
useBuiltIns: false,
shippedProposals: true,
modules: false,
bugfixes: true,
},
],
],
/**
* Enable syntax plugins for stage 3 features. This does **not** transform them,
* it only ensures that babel does not crash when you're using them.
*/
plugins: [
require.resolve('@babel/plugin-syntax-import-meta'),
require.resolve('@babel/plugin-syntax-class-properties'),
require.resolve('@babel/plugin-syntax-numeric-separator'),
require.resolve('@babel/plugin-syntax-dynamic-import'),
],
};
export const systemJsConfig: TransformOptions = {
...es5Config,
plugins: [
...(es5Config.plugins ?? []),
require.resolve('@babel/plugin-proposal-dynamic-import'),
require.resolve('@babel/plugin-transform-modules-systemjs'),
// systemjs adds template literals, we do systemjs after (potential)
// es5 compilation so we need to ensure it stays es5
require.resolve('@babel/plugin-transform-template-literals'),
],
};
export async function babelTransform(filename: string, source: string, config: TransformOptions) {
const largeFile = source.length > 100000;
const result = await transformAsync(source, {
filename,
// prevent generating pretty output for large files
compact: largeFile,
// babel runs out of memory when processing source maps andfor large files
sourceMaps: !largeFile,
...config,
});
if (!result || typeof result.code !== 'string') {
throw new Error('Failed to transform');
}
return result.code;
}
| modernweb-dev/web/packages/dev-server-legacy/src/babelTransform.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-legacy/src/babelTransform.ts",
"repo_id": "modernweb-dev",
"token_count": 665
} | 187 |
'use strict';
exports.__esModule = true;
exports.default = void 0;
var _default = 'bar';
exports.default = _default;
| modernweb-dev/web/packages/dev-server-rollup/test/node/fixtures/commonjs/modules/compiled-esm-default-exports.js/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-rollup/test/node/fixtures/commonjs/modules/compiled-esm-default-exports.js",
"repo_id": "modernweb-dev",
"token_count": 42
} | 188 |
{
"name": "module-a"
} | modernweb-dev/web/packages/dev-server-rollup/test/node/fixtures/resolve-outside-dir/node_modules/module-a/package.json/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-rollup/test/node/fixtures/resolve-outside-dir/node_modules/module-a/package.json",
"repo_id": "modernweb-dev",
"token_count": 13
} | 189 |
declare module '@rollup/plugin-url' {
import { Plugin } from 'rollup';
export default function rollupPluginUrl(options?: any): Plugin;
}
| modernweb-dev/web/packages/dev-server-rollup/types/rollup__plugin-url/index.d.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-rollup/types/rollup__plugin-url/index.d.ts",
"repo_id": "modernweb-dev",
"token_count": 43
} | 190 |
```js script
import { Button } from '../src/Button.js';
export default {
title: 'MDJS Docs/Button',
component: 'my-button',
};
const Template = args => Button(args);
```
# Button
This is a demo showing the button component
```js preview-story
export const Primary = Template.bind({});
Primary.args = { primary: true, label: 'Button' };
```
```js preview-story
export const Secondary = Template.bind({});
Secondary.args = { label: 'Button' };
```
```js preview-story
export const Large = Template.bind({});
Large.args = { size: 'large', label: 'Button' };
```
```js preview-story
export const Small = Template.bind({});
Small.args = { size: 'small', label: 'Button' };
```
## Level 2 heading
- a list
- of things
- to be
- listed
[A link somewhere](./foo.js)
## Code block
```js
console.log('Hello world');
```
| modernweb-dev/web/packages/dev-server-storybook/demo/wc/stories/Button-mdx-docs.stories.md/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-storybook/demo/wc/stories/Button-mdx-docs.stories.md",
"repo_id": "modernweb-dev",
"token_count": 277
} | 191 |
import path from 'path';
import fs from 'fs';
import { pathToFileURL } from 'url';
import { StorybookPluginConfig } from './StorybookPluginConfig.js';
import { createError } from '../utils.js';
import { MainJs, StorybookConfig } from './StorybookConfig.js';
const defaultConfigDir = path.join(process.cwd(), '.storybook');
function validateMainJs(mainJs: MainJs): MainJs {
if (typeof mainJs !== 'object') {
throw createError('main.js must export an object');
}
if (mainJs.stories == null) {
throw createError('Missing stories option in main.js');
}
if (!(Array.isArray(mainJs.stories) || typeof mainJs.stories === 'function')) {
throw createError('Stories option main.js must be an array or function');
}
if (mainJs.addons != null) {
if (!Array.isArray(mainJs.addons)) {
throw createError('Addons in main.js must be an array');
}
if (mainJs.addons.some(addon => addon.startsWith('@storybook'))) {
throw createError(
'Official storybook addons are not es modules, and cannot be loaded from this storybook implementation.',
);
}
}
return mainJs;
}
export async function readStorybookConfig(
pluginConfig: StorybookPluginConfig,
): Promise<StorybookConfig> {
const configDir = pluginConfig.configDir
? path.resolve(pluginConfig.configDir)
: defaultConfigDir;
const commonJsMainPath = path.join(configDir, 'main.cjs');
const mainJsPath = path.join(configDir, 'main.js');
const managerJsPath = path.join(configDir, 'manager.js');
const previewJsPath = path.join(configDir, 'preview.js');
const managerHeadPath = path.join(configDir, 'manager-head.html');
const previewHeadPath = path.join(configDir, 'preview-head.html');
const previewBodyPath = path.join(configDir, 'preview-body.html');
let managerHead: string | undefined = undefined;
let previewHead: string | undefined = undefined;
let previewBody: string | undefined = undefined;
const mainJsExists = fs.existsSync(mainJsPath);
const commonJsMainExists = fs.existsSync(commonJsMainPath);
if (!mainJsExists && !commonJsMainExists) {
throw createError(
`Could not find any storybook configuration at ${mainJsPath} or ${commonJsMainPath}. You can change the storybook config directory using the configDir option.`,
);
}
if (fs.existsSync(managerHeadPath)) {
managerHead = fs.readFileSync(managerHeadPath, 'utf-8');
}
if (fs.existsSync(previewHeadPath)) {
previewHead = fs.readFileSync(previewHeadPath, 'utf-8');
}
if (fs.existsSync(previewBodyPath)) {
previewBody = fs.readFileSync(previewBodyPath, 'utf-8');
}
const mainJs = commonJsMainExists
? validateMainJs((await import(commonJsMainPath)).default)
: validateMainJs((await import(pathToFileURL(mainJsPath).href)).default);
return {
mainJs,
mainJsPath,
managerJsPath,
previewJsPath,
managerHead,
previewHead,
previewBody,
};
}
| modernweb-dev/web/packages/dev-server-storybook/src/shared/config/readStorybookConfig.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server-storybook/src/shared/config/readStorybookConfig.ts",
"repo_id": "modernweb-dev",
"token_count": 974
} | 192 |
/* eslint-disable */
export const foo = () => 'module b foo';
console.log('module b');
window.__moduleBLoaded = true;
| modernweb-dev/web/packages/dev-server/demo/base-path/module-b.js/0 | {
"file_path": "modernweb-dev/web/packages/dev-server/demo/base-path/module-b.js",
"repo_id": "modernweb-dev",
"token_count": 40
} | 193 |
import { html, render } from 'lit-html';
window.__extensionPriority = true; | modernweb-dev/web/packages/dev-server/demo/node-resolve/extension-priority.mjs/0 | {
"file_path": "modernweb-dev/web/packages/dev-server/demo/node-resolve/extension-priority.mjs",
"repo_id": "modernweb-dev",
"token_count": 24
} | 194 |
console.log(
'dynamically importing stage 3 features, these should throw errors on browsers that dont support them but it should not crash babel parsing',
);
import('./stage-3-class-fields.js');
import('./stage-3-private-class-fields.js');
| modernweb-dev/web/packages/dev-server/demo/syntax/stage-3-features.js/0 | {
"file_path": "modernweb-dev/web/packages/dev-server/demo/syntax/stage-3-features.js",
"repo_id": "modernweb-dev",
"token_count": 70
} | 195 |
import { DevServerConfig } from '../config/DevServerConfig';
import { Logger } from '@web/dev-server-core';
import ip from 'ip';
import { bold, cyan, white } from 'nanocolors';
const createAddress = (config: DevServerConfig, host: string, path: string) =>
`http${config.http2 ? 's' : ''}://${host}:${config.port}${path}`;
function logNetworkAddress(config: DevServerConfig, logger: Logger, openPath: string) {
try {
const address = ip.address();
if (typeof address === 'string') {
logger.log(`${white('Network:')} ${cyan(createAddress(config, address, openPath))}`);
}
} catch {
//
}
}
export function logStartMessage(config: DevServerConfig, logger: Logger) {
const prettyHost = config.hostname ?? 'localhost';
let openPath = typeof config.open === 'string' ? config.open : '/';
if (!openPath.startsWith('/')) {
openPath = `/${openPath}`;
}
logger.log(bold('Web Dev Server started...'));
logger.log('');
logger.group();
logger.log(`${white('Root dir:')} ${cyan(config.rootDir)}`);
logger.log(`${white('Local:')} ${cyan(createAddress(config, prettyHost, openPath))}`);
logNetworkAddress(config, logger, openPath);
logger.groupEnd();
logger.log('');
}
| modernweb-dev/web/packages/dev-server/src/logger/logStartMessage.ts/0 | {
"file_path": "modernweb-dev/web/packages/dev-server/src/logger/logStartMessage.ts",
"repo_id": "modernweb-dev",
"token_count": 425
} | 196 |
const VERSION = Symbol.for('msw-integration-layer::version');
/**
* This wrapper was made to be forward/backward compatible with potential future versions
* of the underlying mocking library. It's api should not change, it should not have dependencies,
* and it's import should be pure and non-sideeffectful.
*/
export const http = {
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
get: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'get', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
post: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'post', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
put: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'put', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
patch: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'patch', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
delete: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'delete', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
options: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'options', endpoint, handler };
},
/**
* @param {string} endpoint
* @param {import('./types.js').handler} handler
* @returns {import('./types.js').Mock}
*/
head: (endpoint, handler) => {
return { [VERSION]: '1.x.x', method: 'head', endpoint, handler };
},
};
| modernweb-dev/web/packages/mocks/http.js/0 | {
"file_path": "modernweb-dev/web/packages/mocks/http.js",
"repo_id": "modernweb-dev",
"token_count": 744
} | 197 |
export interface Mock {
method: string;
endpoint: string;
handler: handler;
[key: symbol]: string;
}
export type handler = ({
request,
cookies,
params,
}: {
request: Request;
cookies: Record<string, unknown>;
params: Record<string, unknown>;
}) => Response | Promise<Response>;
| modernweb-dev/web/packages/mocks/types.ts/0 | {
"file_path": "modernweb-dev/web/packages/mocks/types.ts",
"repo_id": "modernweb-dev",
"token_count": 94
} | 198 |
import {
PolyfillsLoaderConfig,
File,
GeneratedFile,
PolyfillFile,
PolyfillsLoader,
LegacyEntrypoint,
} from './types.js';
import { transformAsync } from '@babel/core';
import { minify } from 'terser';
import { fileTypes, hasFileOfType, cleanImportPath } from './utils.js';
import { createPolyfillsData } from './createPolyfillsData.js';
import path from 'path';
/**
* Function which loads a script dynamically, returning a thenable (object with then function)
* because Promise might not be loaded yet
*/
const loadScriptFunction = `
function loadScript(src, type, attributes) {
return new Promise(function (resolve) {
var script = document.createElement('script');
script.fetchPriority = 'high';
function onLoaded() {
if (script.parentElement) {
script.parentElement.removeChild(script);
}
resolve();
}
script.src = src;
script.onload = onLoaded;
if (attributes) {
attributes.forEach(function (att) {
script.setAttribute(att.name, att.value);
});
}
script.onerror = function () {
console.error('[polyfills-loader] failed to load: ' + src + ' check the network tab for HTTP status.');
onLoaded();
}
if (type) script.type = type;
document.head.appendChild(script);
});
}
`;
/**
* Returns the loadScriptFunction if a script will be loaded for this config.
*/
function createLoadScriptCode(cfg: PolyfillsLoaderConfig, polyfills: PolyfillFile[]) {
const { MODULE, SCRIPT } = fileTypes;
if (
(polyfills && polyfills.length > 0) ||
[SCRIPT, MODULE].some(type => hasFileOfType(cfg, type))
) {
return loadScriptFunction;
}
return '';
}
/**
* Returns a js statement which loads the given resource in the browser.
*/
function createLoadFile(file: File) {
const resourcePath = cleanImportPath(file.path);
const attributesAsJsCodeString = file.attributes ? JSON.stringify(file.attributes) : '[]';
switch (file.type) {
case fileTypes.SCRIPT:
return `loadScript('${resourcePath}', null, ${attributesAsJsCodeString})`;
case fileTypes.MODULE:
return `loadScript('${resourcePath}', 'module', ${attributesAsJsCodeString})`;
case fileTypes.MODULESHIM:
return `loadScript('${resourcePath}', 'module-shim', ${attributesAsJsCodeString})`;
case fileTypes.SYSTEMJS:
return `System.import('${resourcePath}')`;
default:
throw new Error(`Unknown resource type: ${file.type}`);
}
}
/**
* Creates a statement which loads the given resources in the browser sequentially.
*/
function createLoadFiles(files: File[]) {
if (files.length === 1) {
return createLoadFile(files[0]);
}
return `[
${files.map(r => `function() { return ${createLoadFile(r)} }`)}
].reduce(function (a, c) {
return a.then(c);
}, Promise.resolve())`;
}
/**
* Creates js code which loads the correct resources, uses runtime feature detection
* of legacy resources are configured to load the appropriate resources.
*/
function createLoadFilesFunction(cfg: PolyfillsLoaderConfig) {
const loadResources = cfg.modern && cfg.modern.files ? createLoadFiles(cfg.modern.files) : '';
if (!cfg.legacy || cfg.legacy.length === 0) {
return loadResources;
}
function reduceFn(all: string, current: LegacyEntrypoint, i: number) {
return `${all}${i !== 0 ? ' else ' : ''}if (${current.test}) {
${createLoadFiles(current.files)}
}`;
}
const loadLegacyResources = cfg.legacy.reduce(reduceFn, '');
return `${loadLegacyResources} else {
${loadResources}
}`;
}
/**
* Creates js code which waits for polyfills if applicable, and executes
* the code which loads entrypoints.
*/
function createLoadFilesCode(cfg: PolyfillsLoaderConfig, polyfills: PolyfillFile[]) {
const loadFilesFunction = createLoadFilesFunction(cfg);
// create a separate loadFiles to be run after polyfills
if (polyfills && polyfills.length > 0) {
return `
function loadFiles() {
${loadFilesFunction}
}
if (polyfills.length) {
Promise.all(polyfills).then(loadFiles);
} else {
loadFiles();
}`;
}
// there are no polyfills, load entries straight away
return `${loadFilesFunction}`;
}
/**
* Returns the relative path to a polyfill (in posix path format suitable for
* a relative URL) given the plugin configuation
*/
function relativePolyfillPath(polyfillPath: string, cfg: PolyfillsLoaderConfig) {
const relativePath = path.join(cfg.relativePathToPolyfills || './', polyfillPath);
return relativePath.split(path.sep).join(path.posix.sep);
}
/**
* Creates code which loads the configured polyfills
*/
function createPolyfillsLoaderCode(
cfg: PolyfillsLoaderConfig,
polyfills: PolyfillFile[],
): { loadPolyfillsCode: string; generatedFiles: GeneratedFile[] } {
if (!polyfills || polyfills.length === 0) {
return { loadPolyfillsCode: '', generatedFiles: [] };
}
const generatedFiles: GeneratedFile[] = [];
let loadPolyfillsCode = ' var polyfills = [];';
polyfills.forEach(polyfill => {
let loadScript = `loadScript('./${relativePolyfillPath(polyfill.path, cfg)}')`;
if (polyfill.initializer) {
loadScript += `.then(function () { ${polyfill.initializer} })`;
}
const loadPolyfillCode = `polyfills.push(${loadScript});`;
if (polyfill.test) {
loadPolyfillsCode += `if (${polyfill.test}) { ${loadPolyfillCode} }`;
} else {
loadPolyfillsCode += `${loadPolyfillCode}`;
}
generatedFiles.push({
type: polyfill.type,
path: polyfill.path,
content: polyfill.content,
});
});
return { loadPolyfillsCode, generatedFiles };
}
/**
* Creates a loader script that executes immediately, loading the configured
* polyfills and resources (app entrypoints, scripts etc.).
*/
export async function createPolyfillsLoader(
cfg: PolyfillsLoaderConfig,
): Promise<PolyfillsLoader | null> {
let polyfillFiles = await createPolyfillsData(cfg);
const coreJs = polyfillFiles.find(pf => pf.name === 'core-js');
polyfillFiles = polyfillFiles.filter(pf => pf !== coreJs);
const { loadPolyfillsCode, generatedFiles } = createPolyfillsLoaderCode(cfg, polyfillFiles);
let code = `
${createLoadScriptCode(cfg, polyfillFiles)}
${loadPolyfillsCode}
${createLoadFilesCode(cfg, polyfillFiles)}
`;
if (coreJs) {
generatedFiles.push({
type: fileTypes.SCRIPT,
path: coreJs.path,
content: coreJs.content,
});
// if core-js should be polyfilled, load it first and then the rest because most
// polyfills rely on things like Promise to be already loaded
code = `(function () {
function polyfillsLoader() {
${code}
}
if (${coreJs.test}) {
var s = document.createElement('script');
s.fetchPriority = 'high';
function onLoaded() {
document.head.removeChild(s);
polyfillsLoader();
}
s.src = "./${relativePolyfillPath(coreJs.path, cfg)}";
s.onload = onLoaded;
s.onerror = function () {
console.error('[polyfills-loader] failed to load: ' + s.src + ' check the network tab for HTTP status.');
onLoaded();
}
document.head.appendChild(s);
} else {
polyfillsLoader();
}
})();`;
} else {
code = `(function () { ${code} })();`;
}
if (cfg.minify) {
const output = await minify(code);
if (!output || !output.code) {
throw new Error('Could not minify loader.');
}
({ code } = output);
} else {
const output = await transformAsync(code, { babelrc: false, configFile: false });
if (!output || !output.code) {
throw new Error('Could not prettify loader.');
}
({ code } = output);
}
if (cfg.externalLoaderScript) {
generatedFiles.push({ type: 'script', path: 'loader.js', content: code });
}
return { code, polyfillFiles: generatedFiles };
}
| modernweb-dev/web/packages/polyfills-loader/src/createPolyfillsLoader.ts/0 | {
"file_path": "modernweb-dev/web/packages/polyfills-loader/src/createPolyfillsLoader.ts",
"repo_id": "modernweb-dev",
"token_count": 2852
} | 199 |
(function () {
function loadScript(src, type, attributes) {
return new Promise(function (resolve) {
var script = document.createElement('script');
script.fetchPriority = 'high';
function onLoaded() {
if (script.parentElement) {
script.parentElement.removeChild(script);
}
resolve();
}
script.src = src;
script.onload = onLoaded;
if (attributes) {
attributes.forEach(function (att) {
script.setAttribute(att.name, att.value);
});
}
script.onerror = function () {
console.error('[polyfills-loader] failed to load: ' + src + ' check the network tab for HTTP status.');
onLoaded();
};
if (type) script.type = type;
document.head.appendChild(script);
});
}
var polyfills = [];
if (!('fetch' in window)) {
polyfills.push(loadScript('./polyfills/fetch.js'));
}
polyfills.push(loadScript('./polyfills/systemjs.js'));
function loadFiles() {
[function () {
return loadScript('./app.js', 'module', []);
}, function () {
return loadScript('./shared.js', null, []);
}, function () {
return System.import('./other.js');
}].reduce(function (a, c) {
return a.then(c);
}, Promise.resolve());
}
if (polyfills.length) {
Promise.all(polyfills).then(loadFiles);
} else {
loadFiles();
}
})(); | modernweb-dev/web/packages/polyfills-loader/test/snapshots/createPolyfillsLoader/module-resources.js/0 | {
"file_path": "modernweb-dev/web/packages/polyfills-loader/test/snapshots/createPolyfillsLoader/module-resources.js",
"repo_id": "modernweb-dev",
"token_count": 591
} | 200 |
<html><head>
<script type="importmap">{ "imports": { "foo": "bar" } }</script>
</head>
<body><div>before</div>
<script type="module" src="./module-a.js"></script>
<div>after</div>
<script>(function () {
function loadScript(src, type, attributes) {
return new Promise(function (resolve) {
var script = document.createElement('script');
script.fetchPriority = 'high';
function onLoaded() {
if (script.parentElement) {
script.parentElement.removeChild(script);
}
resolve();
}
script.src = src;
script.onload = onLoaded;
if (attributes) {
attributes.forEach(function (att) {
script.setAttribute(att.name, att.value);
});
}
script.onerror = function () {
console.error('[polyfills-loader] failed to load: ' + src + ' check the network tab for HTTP status.');
onLoaded();
};
if (type) script.type = type;
document.head.appendChild(script);
});
}
loadScript('./app.js', 'module', []);
})();</script></body></html> | modernweb-dev/web/packages/polyfills-loader/test/snapshots/injectPolyfillsLoader/no-importmap-polyfill.html/0 | {
"file_path": "modernweb-dev/web/packages/polyfills-loader/test/snapshots/injectPolyfillsLoader/no-importmap-polyfill.html",
"repo_id": "modernweb-dev",
"token_count": 473
} | 201 |
export function mySubFunction() {
return 'mySubFunction';
}
| modernweb-dev/web/packages/rollup-plugin-copy/test/fixture/sub/mySubFunction.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-copy/test/fixture/sub/mySubFunction.js",
"repo_id": "modernweb-dev",
"token_count": 18
} | 202 |
import './shared.js';
console.log('page-c.js');
| modernweb-dev/web/packages/rollup-plugin-html/demo/mpa/pages/page-c.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-html/demo/mpa/pages/page-c.js",
"repo_id": "modernweb-dev",
"token_count": 20
} | 203 |
import { ScriptModuleTag } from '../RollupPluginHTMLOptions';
export interface InputAsset {
filePath: string;
hashed: boolean;
content: Buffer;
}
export interface InputData {
html: string;
name: string;
moduleImports: ScriptModuleTag[];
inlineModules: ScriptModuleTag[];
assets: InputAsset[];
filePath?: string;
}
| modernweb-dev/web/packages/rollup-plugin-html/src/input/InputData.ts/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-html/src/input/InputData.ts",
"repo_id": "modernweb-dev",
"token_count": 103
} | 204 |
import './modules/module-c.js';
console.log('entrypoint-c.js');
| modernweb-dev/web/packages/rollup-plugin-html/test/fixtures/rollup-plugin-html/entrypoint-c.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-html/test/fixtures/rollup-plugin-html/entrypoint-c.js",
"repo_id": "modernweb-dev",
"token_count": 25
} | 205 |
<html>
<body>
<p>page-c.html</p>
<script type="module" src="./page-c.js"></script>
<script type="module" src="./shared.js"></script>
</body>
</html>
| modernweb-dev/web/packages/rollup-plugin-html/test/fixtures/rollup-plugin-html/pages/page-c.html/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-html/test/fixtures/rollup-plugin-html/pages/page-c.html",
"repo_id": "modernweb-dev",
"token_count": 75
} | 206 |
# @web/rollup-plugin-import-meta-assets
## 2.2.1
### Patch Changes
- 1c0088de: Update Rollup to version 4.
## 2.2.0
### Minor Changes
- c185cbaa: Set minimum node version to 18
## 2.1.0
### Minor Changes
- a8039a46: Enabled using dynamic import vars when importing assets
## 2.0.2
### Patch Changes
- db02e2df: Make import-meta-assets rollup plugin ignore patterns like "new URL('./', import.meta.url)" that reference directories.
## 2.0.1
### Patch Changes
- f64cc232: Allow import-meta-assets rollup plugin to bundle meta assets that use backticks, but do not contain any dynamic expressions inside the template literal.
## 2.0.0
### Major Changes
- febd9d9d: Set node 16 as the minimum version.
- 72c63bc5: Require Rollup@v3.x and update all Rollup related dependencies to latest.
## 1.0.8
### Patch Changes
- 1113fa09: Update `@rollup/pluginutils`
## 1.0.7
### Patch Changes
- d3448166: Allow ignoring assets during transformation
## 1.0.6
### Patch Changes
- b77e5d16: fix(rollup-plugin-import-meta-assets): skip unnecessary sourcemap generation
## 1.0.5
### Patch Changes
- 7fd7a799: fix(rollup-plugin-import-meta-assets): fix outputted sourcemaps
## 1.0.4
### Patch Changes
- 5bb5dd0: fix type reference
## 1.0.3
### Patch Changes
- 279f756: ---
fix warn() code when error was caught
## 1.0.2
### Patch Changes
- 68e24b6: publish correct entrypoint
## 1.0.1
### Patch Changes
- fd9fe56: publish files
## 1.0.0
### Major Changes
- 401e225: First release
| modernweb-dev/web/packages/rollup-plugin-import-meta-assets/CHANGELOG.md/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-import-meta-assets/CHANGELOG.md",
"repo_id": "modernweb-dev",
"token_count": 529
} | 207 |
<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink">
<rect x="10" y="10" height="100" width="100"
style="stroke:#000000; fill: #ff0000"/>
</svg>
| modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/fixtures/one.svg/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/fixtures/one.svg",
"repo_id": "modernweb-dev",
"token_count": 97
} | 208 |
const nameOne = 'one-name';
const imageOne = new URL(new URL('assets/one-deep-ZInu4dBJ.svg', import.meta.url).href, import.meta.url).href;
const nameTwo = 'two-name';
const imageTwo = new URL(new URL('assets/two-deep--yckvrYd.svg', import.meta.url).href, import.meta.url).href;
const nameThree = 'three-name';
const imageThree = new URL(new URL('assets/three-deep-CDdgprDC.svg', import.meta.url).href, import.meta.url).href;
const nameFour = 'four-name';
const imageFour = new URL(new URL('assets/four-deep-lJVunLww.svg', import.meta.url).href, import.meta.url).href;
console.log({
[nameOne]: imageOne,
[nameTwo]: imageTwo,
[nameThree]: imageThree,
[nameFour]: imageFour,
});
| modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/snapshots/different-asset-levels-bundle.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/snapshots/different-asset-levels-bundle.js",
"repo_id": "modernweb-dev",
"token_count": 256
} | 209 |
const justUrlObject = new URL(new URL('assets/one-PkYUFgN1.svg', import.meta.url).href, import.meta.url);
const href = new URL(new URL('assets/two-mXcSFMIh.svg', import.meta.url).href, import.meta.url).href;
const pathname = new URL(new URL('assets/three-LRYckR_0.svg', import.meta.url).href, import.meta.url).pathname;
const searchParams = new URL(new URL('assets/four-rNTiHfqi.svg', import.meta.url).href, import.meta.url).searchParams;
const someJpg = new URL('./image.jpg', import.meta.url);
console.log({
justUrlObject,
href,
pathname,
searchParams,
someJpg,
});
| modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/snapshots/transform-bundle-ignored.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-import-meta-assets/test/snapshots/transform-bundle-ignored.js",
"repo_id": "modernweb-dev",
"token_count": 223
} | 210 |
import './shared.js';
| modernweb-dev/web/packages/rollup-plugin-polyfills-loader/test/fixtures/entrypoint-a.js/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-polyfills-loader/test/fixtures/entrypoint-a.js",
"repo_id": "modernweb-dev",
"token_count": 8
} | 211 |
<html><head>
<link rel="preload" href="./entrypoint-b.js" as="script" />
<link rel="preload" href="./entrypoint-a.js" as="script" />
</head><body><script>(function () {
function loadScript(src, type, attributes) {
return new Promise(function (resolve) {
var script = document.createElement('script');
script.fetchPriority = 'high';
function onLoaded() {
if (script.parentElement) {
script.parentElement.removeChild(script);
}
resolve();
}
script.src = src;
script.onload = onLoaded;
if (attributes) {
attributes.forEach(function (att) {
script.setAttribute(att.name, att.value);
});
}
script.onerror = function () {
console.error('[polyfills-loader] failed to load: ' + src + ' check the network tab for HTTP status.');
onLoaded();
};
if (type) script.type = type;
document.head.appendChild(script);
});
}
var polyfills = [];
polyfills.push(loadScript('./polyfills/systemjs.dabf4e8006a3be11acd4b6981abd9943.js'));
function loadFiles() {
[function () {
return System.import('./entrypoint-b.js');
}, function () {
return System.import('./entrypoint-a.js');
}].reduce(function (a, c) {
return a.then(c);
}, Promise.resolve());
}
if (polyfills.length) {
Promise.all(polyfills).then(loadFiles);
} else {
loadFiles();
}
})();</script></body></html> | modernweb-dev/web/packages/rollup-plugin-polyfills-loader/test/snapshots/systemjs.html/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-polyfills-loader/test/snapshots/systemjs.html",
"repo_id": "modernweb-dev",
"token_count": 627
} | 212 |
{
"compilerOptions": {
"lib": ["webworker"]
},
"exclude": ["dist", "demo"]
} | modernweb-dev/web/packages/rollup-plugin-workbox/tsconfig.override.json/0 | {
"file_path": "modernweb-dev/web/packages/rollup-plugin-workbox/tsconfig.override.json",
"repo_id": "modernweb-dev",
"token_count": 38
} | 213 |
import { stringifyProcessEnvs } from '@storybook/core-common';
import { build } from 'esbuild';
import { join } from 'path';
import type { Plugin } from 'rollup';
import { esbuildPluginCommonjsNamedExports } from './esbuild-plugin-commonjs-named-exports.js';
import { getNodeModuleDir } from './get-node-module-dir.js';
export const PREBUNDLED_MODULES_DIR = 'node_modules/.prebundled_modules';
export function rollupPluginPrebundleModules(env: Record<string, string>): Plugin {
const modulePaths: Record<string, string> = {};
return {
name: 'rollup-plugin-prebundle-modules',
async buildStart() {
const esbuildPluginCommonjs = (await import('@chialab/esbuild-plugin-commonjs')).default; // for CJS compatibility
const modules = CANDIDATES.filter(moduleExists);
for (const module of modules) {
modulePaths[module] = join(
process.cwd(),
PREBUNDLED_MODULES_DIR,
module.endsWith('.js') ? module : `${module}.js`,
);
}
await build({
entryPoints: modules,
outdir: PREBUNDLED_MODULES_DIR,
bundle: true,
format: 'esm',
splitting: true,
sourcemap: true,
alias: {
assert: require.resolve('browser-assert'),
lodash: getNodeModuleDir('lodash-es'), // more optimal, but also solves esbuild incorrectly compiling lodash/_nodeUtil
path: require.resolve('path-browserify'),
/* for @storybook/addon-docs */
...(moduleExists('@storybook/react-dom-shim') && {
'@storybook/react-dom-shim': getReactDomShimAlias(),
}),
},
define: {
...stringifyProcessEnvs(env),
},
plugins: [
/* for @storybook/addon-docs */
// tocbot can't be automatically transformed by @chialab/esbuild-plugin-commonjs
// so we need a manual wrapper
esbuildPluginCommonjsNamedExports('tocbot', ['default', 'init', 'destroy']),
esbuildPluginCommonjs(),
],
});
},
async resolveId(source) {
return modulePaths[source];
},
};
}
// this is different to https://github.com/storybookjs/storybook/blob/v7.0.0/code/lib/builder-vite/src/optimizeDeps.ts#L7
// builder-vite bundles different dependencies for performance reasons
// we aim only at browserifying NodeJS dependencies (CommonJS/process.env/...)
export const CANDIDATES = [
/* for different packages */
'tiny-invariant',
/* for @storybook/addon-interactions */
'jest-mock',
// @testing-library has ESM, but imports/exports are not working correctly between packages
// specifically "@testing-library/user-event" has "dist/esm/utils/misc/getWindow.js" (see https://cdn.jsdelivr.net/npm/@testing-library/user-event@14.4.3/dist/esm/utils/misc/getWindow.js)
// which uses "@testing-library/dom" in `import { getWindowFromNode } from '@testing-library/dom/dist/helpers.js';`
// which doesn't get resolved to "@testing-library/dom" ESM "dom.esm.js" (see https://cdn.jsdelivr.net/npm/@testing-library/dom@9.3.1/dist/@testing-library/dom.esm.js)
// and instead gets resolved to "@testing-library/dom" CommonJS "dist/helpers.js" (see https://cdn.jsdelivr.net/npm/@testing-library/dom@9.3.1/dist/helpers.js)
'@testing-library/dom',
'@testing-library/user-event',
/* for @storybook/addon-docs */
'@storybook/react-dom-shim', // needs special resolution
'color-convert',
'doctrine',
'lodash/cloneDeep.js',
'lodash/mapValues.js',
'lodash/pickBy.js',
'lodash/throttle.js',
'lodash/uniq.js',
'memoizerific',
'react',
'react-dom',
'tocbot',
/* for @storybook/addon-a11y */
'axe-core',
];
function getReactDomShimAlias() {
const { version } = require('react-dom');
return version.startsWith('18')
? require.resolve('@storybook/react-dom-shim/dist/react-18').replace(/\.js$/, '.mjs')
: require.resolve('@storybook/react-dom-shim').replace(/\.js$/, '.mjs');
}
function moduleExists(moduleName: string) {
try {
require.resolve(moduleName, { paths: [process.cwd()] });
return true;
} catch (e) {
return false;
}
}
| modernweb-dev/web/packages/storybook-builder/src/rollup-plugin-prebundle-modules.ts/0 | {
"file_path": "modernweb-dev/web/packages/storybook-builder/src/rollup-plugin-prebundle-modules.ts",
"repo_id": "modernweb-dev",
"token_count": 1625
} | 214 |
// this file is autogenerated with the generate-mjs-dts-entrypoints script
import cjsEntrypoint from './dist/preset.js';
const { core } = cjsEntrypoint;
export { core };
| modernweb-dev/web/packages/storybook-framework-web-components/preset.mjs/0 | {
"file_path": "modernweb-dev/web/packages/storybook-framework-web-components/preset.mjs",
"repo_id": "modernweb-dev",
"token_count": 56
} | 215 |
// Don't edit this file directly. It is generated by generate-ts-configs script
{
"extends": "../../tsconfig.browser-base.json",
"compilerOptions": {
"module": "ESNext",
"outDir": "./dist",
"rootDir": "./src",
"composite": true,
"allowJs": true,
"checkJs": true,
"emitDeclarationOnly": true
},
"references": [],
"include": [
"src",
"types"
],
"exclude": [
"src/browser",
"tests",
"dist"
]
} | modernweb-dev/web/packages/storybook-utils/tsconfig.json/0 | {
"file_path": "modernweb-dev/web/packages/storybook-utils/tsconfig.json",
"repo_id": "modernweb-dev",
"token_count": 195
} | 216 |
import { Page, JSCoverageEntry } from 'puppeteer-core';
import { TestRunnerCoreConfig } from '@web/test-runner-core';
import { v8ToIstanbul } from '@web/test-runner-coverage-v8';
import { SessionResult } from '@web/test-runner-core';
import { Mutex } from 'async-mutex';
const mutex = new Mutex();
declare global {
interface Window {
__bringTabToFront: (id: string) => void;
__releaseLock: (id: string) => void;
}
}
export class ChromeLauncherPage {
private config: TestRunnerCoreConfig;
private testFiles: string[];
private product: string;
public puppeteerPage: Page;
private nativeInstrumentationEnabledOnPage = false;
private patchAdded = false;
private resolvers: Record<string, () => void> = {};
constructor(
config: TestRunnerCoreConfig,
testFiles: string[],
product: string,
puppeteerPage: Page,
) {
this.config = config;
this.testFiles = testFiles;
this.product = product;
this.puppeteerPage = puppeteerPage;
}
async runSession(url: string, coverage: boolean) {
if (
coverage &&
this.config.coverageConfig?.nativeInstrumentation !== false &&
this.product === 'chromium'
) {
if (this.nativeInstrumentationEnabledOnPage) {
await this.puppeteerPage.coverage.stopJSCoverage();
}
this.nativeInstrumentationEnabledOnPage = true;
await this.puppeteerPage.coverage.startJSCoverage({
includeRawScriptCoverage: true,
});
}
// Patching the browser page to workaround an issue in the new headless mode of Chrome where some functions
// with callbacks (requestAnimationFrame and requestIdleCallback) are not executing their callbacks.
// https://github.com/puppeteer/puppeteer/issues/10350
if (!this.patchAdded) {
await this.puppeteerPage.exposeFunction('__bringTabToFront', (id: string) => {
const promise = new Promise(resolve => {
this.resolvers[id] = resolve as () => void;
});
return mutex.runExclusive(async () => {
await this.puppeteerPage.bringToFront();
await promise;
});
});
await this.puppeteerPage.exposeFunction('__releaseLock', (id: string) => {
this.resolvers[id]?.();
});
await this.puppeteerPage.evaluateOnNewDocument(() => {
// eslint-disable-next-line @typescript-eslint/ban-types
function patchFunction(name: string, fn: Function) {
(window as any)[name] = (...args: unknown[]) => {
const result = fn.call(window, ...args);
const id = Math.random().toString().substring(2);
// Make sure that the tab running the test code is brought back to the front.
window.__bringTabToFront(id);
fn.call(window, () => {
window.__releaseLock(id);
});
return result;
};
}
patchFunction('requestAnimationFrame', window.requestAnimationFrame);
patchFunction('requestIdleCallback', window.requestIdleCallback);
});
this.patchAdded = true;
}
await this.puppeteerPage.setViewport({ height: 600, width: 800 });
await this.puppeteerPage.goto(url);
}
async stopSession(): Promise<SessionResult> {
const testCoverage = await this.collectTestCoverage(this.config, this.testFiles);
// navigate to an empty page to kill any running code on the page, stopping timers and
// breaking a potential endless reload loop
await this.puppeteerPage.goto('about:blank');
return { testCoverage };
}
private async collectTestCoverage(config: TestRunnerCoreConfig, testFiles: string[]) {
const userAgentPromise = this.puppeteerPage
.browser()
.userAgent()
.catch(() => undefined);
try {
const coverageFromBrowser = await this.puppeteerPage.evaluate(
() => (window as any).__coverage__,
);
if (coverageFromBrowser) {
// coverage was generated by JS, return that
return coverageFromBrowser;
}
} catch (error) {
// evaluate throws when the test navigates in the browser
}
if (config.coverageConfig?.nativeInstrumentation === false) {
throw new Error(
'Coverage is enabled with nativeInstrumentation disabled. ' +
'Expected coverage provided in the browser as a global __coverage__ variable.' +
'Use a plugin like babel-plugin-istanbul to generate the coverage, or enable native instrumentation.',
);
}
if (!this.nativeInstrumentationEnabledOnPage) {
return undefined;
}
const [userAgent, coverageResult] = await Promise.all([
userAgentPromise,
this.puppeteerPage.coverage?.stopJSCoverage(),
]);
const v8Coverage = coverageResult
?.map(entry => entry.rawScriptCoverage)
.filter((cov): cov is Required<JSCoverageEntry>['rawScriptCoverage'] => cov !== undefined);
this.nativeInstrumentationEnabledOnPage = false;
return v8ToIstanbul(config, testFiles, v8Coverage, userAgent);
}
}
| modernweb-dev/web/packages/test-runner-chrome/src/ChromeLauncherPage.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-chrome/src/ChromeLauncherPage.ts",
"repo_id": "modernweb-dev",
"token_count": 1882
} | 217 |
# Test Runner Commands
Commands for executing code server-side during your tests in the browser. To control the browser page, access the file system, or execute NodeJS libraries.
Built-in commands can change the viewport, emulate media queries or set the user agent. You can create custom commands to implement your own functionalities.
See [our website](https://modern-web.dev/docs/test-runner/commands/) for full documentation.
| modernweb-dev/web/packages/test-runner-commands/README.md/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-commands/README.md",
"repo_id": "modernweb-dev",
"token_count": 100
} | 218 |
import { TestRunnerPlugin } from '@web/test-runner-core';
import type { ChromeLauncher } from '@web/test-runner-chrome';
import type { PlaywrightLauncher } from '@web/test-runner-playwright';
export interface Viewport {
width: number;
height: number;
// puppeteer only
deviceScaleFactor?: number;
isLandscape?: boolean;
}
function isObject(payload: unknown): payload is Record<string, unknown> {
return payload != null && typeof payload === 'object';
}
function isViewportObject(payload: unknown): payload is { width: number; height: number } {
if (!isObject(payload)) throw new Error('You must provide a viewport object');
if (payload.height == null) throw new Error('You must provide a viewport width');
if (payload.width == null) throw new Error('You must provide a viewport width');
if (typeof payload.height !== 'number') throw new Error('Viewport height must be a number');
if (typeof payload.height !== 'number') throw new Error('Viewport width must be a number');
if (payload.isMobile != null)
throw new Error('isMobile cannot be used because it triggers a page reload');
if (payload.hasTouch != null)
throw new Error('hasTouch cannot be used because it triggers a page reload');
return true;
}
export function setViewportPlugin(): TestRunnerPlugin {
return {
name: 'set-viewport-command',
async executeCommand({ command, payload, session }) {
if (command === 'set-viewport') {
if (!isViewportObject(payload)) {
throw new Error('You must provide a viewport object');
}
if (session.browser.type === 'puppeteer') {
const page = (session.browser as ChromeLauncher).getPage(session.id);
await page.setViewport(payload);
return true;
}
if (session.browser.type === 'playwright') {
const page = (session.browser as PlaywrightLauncher).getPage(session.id);
await page.setViewportSize(payload);
return true;
}
throw new Error(
`Setting viewport is not supported for browser type ${session.browser.type}.`,
);
}
},
};
}
| modernweb-dev/web/packages/test-runner-commands/src/setViewportPlugin.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-commands/src/setViewportPlugin.ts",
"repo_id": "modernweb-dev",
"token_count": 721
} | 219 |
import path from 'path';
import { runTests } from '@web/test-runner-core/test-helpers';
import { chromeLauncher } from '@web/test-runner-chrome';
import { playwrightLauncher } from '@web/test-runner-playwright';
import { selectOptionPlugin } from '../../src/selectOptionPlugin.js';
describe('selectOptionPlugin', function test() {
this.timeout(20000);
it('can send keys on puppeteer', async () => {
await runTests({
files: [path.join(__dirname, 'puppeteer-test.js')],
browsers: [chromeLauncher()],
plugins: [selectOptionPlugin()],
});
});
it('can send keys on playwright', async () => {
await runTests({
files: [path.join(__dirname, 'playwright-test.js')],
browsers: [
playwrightLauncher({ product: 'chromium' }),
playwrightLauncher({ product: 'firefox' }),
playwrightLauncher({ product: 'webkit' }),
],
plugins: [selectOptionPlugin()],
});
});
});
| modernweb-dev/web/packages/test-runner-commands/test/select-option/selectOptionPlugin.test.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-commands/test/select-option/selectOptionPlugin.test.ts",
"repo_id": "modernweb-dev",
"token_count": 351
} | 220 |
# @web/test-runner-core
## 0.13.1
### Patch Changes
- e657791f: Vulnerability fix in `ip` package.
For more info, see:
- https://github.com/advisories/GHSA-78xj-cgh5-2h22
- https://github.com/indutny/node-ip/issues/136#issuecomment-1952083593
## 0.13.0
### Minor Changes
- c185cbaa: Set minimum node version to 18
### Patch Changes
- Updated dependencies [c185cbaa]
- @web/dev-server-core@0.7.0
- @web/browser-logs@0.4.0
## 0.12.0
### Minor Changes
- 43be7391: Add TestSession to filterBrowserLogs args so logs can be filtered on session result
## 0.11.6
### Patch Changes
- 640ba85f: added types for main entry point
- Updated dependencies [640ba85f]
- @web/dev-server-core@0.6.2
- @web/browser-logs@0.3.4
## 0.11.5
### Patch Changes
- Updated dependencies [7f0f4315]
- @web/dev-server-core@0.6.0
## 0.11.4
### Patch Changes
- c69e3fcc: Destroy consumer when it is used and refactor the caching code for readability
## 0.11.3
### Patch Changes
- 860fca0e: Fixes security vulnerability in make-dir < v4.0.0.
## 0.11.2
### Patch Changes
- 015766e9: Use new headless chrome mode
- Updated dependencies [015766e9]
- @web/browser-logs@0.3.2
## 0.11.1
### Patch Changes
- c26d3730: Update TypeScript
- Updated dependencies [0cd3a2f8]
- Updated dependencies [c26d3730]
- @web/browser-logs@0.3.1
- @web/dev-server-core@0.5.1
## 0.11.0
### Minor Changes
- febd9d9d: Set node 16 as the minimum version.
### Patch Changes
- Updated dependencies [ca715faf]
- Updated dependencies [febd9d9d]
- @web/dev-server-core@0.5.0
- @web/browser-logs@0.3.0
## 0.10.29
### Patch Changes
- cdeafe4a: fix: enable file watcher in manual mode
- 1113fa09: Update `@rollup/pluginutils`
- 817d674b: Update `browserslist-useragent`
- 445b20e6: Update `convert-source-map`
- bd12ff9b: Update `rollup/plugin-replace`
- 8128ca53: Update @rollup/plugin-replace
- Updated dependencies [c103f166]
- Updated dependencies [9b83280e]
- @web/dev-server-core@0.4.1
- @web/browser-logs@0.2.6
## 0.10.28
### Patch Changes
- ac05ca5d: Add option to disable the fileWatcher in the dev server, to allow the test-runner to run once without files added to the watcher.
- Updated dependencies [ac05ca5d]
- Updated dependencies [acc0a84c]
- Updated dependencies [81db401b]
- @web/dev-server-core@0.4.0
## 0.10.27
### Patch Changes
- 570cdf70: - improve caching of snapshots in-memory
- don't block browser command on writing snapshot to disk
- don't write snapshot to disk for each change, batch write per file
- Updated dependencies [39610b4c]
- @web/dev-server-core@0.3.18
## 0.10.26
### Patch Changes
- 336dc2ba: Check isTTY to prevent node from crashing/exiting early
## 0.10.25
### Patch Changes
- ec41a73b: Use https module when making requests over SSL
## 0.10.24
### Patch Changes
- 88a38abf: Allow http2/ssl options to be set in WTR config
## 0.10.23
### Patch Changes
- cdef38b3: Adds limited reporter support to test-helpers
- f4ed8156: Evaluate `files` as a glob list, rather than adding the result of each string to the file list.
This allow `files` glob exclude patterns e.g.
```js
export default {
files: [
'**/*.spec.ts', // include `.spec.ts` files
'!**/*.e2e.spec.ts', // exclude `.e2e.spec.ts` files
'!**/node_module/**/*', // exclude any node modules
],
};
```
If you were relying on each glob string pattern being evaluated on it's own, this is a breaking change.
## 0.10.22
### Patch Changes
- 64bd29ac: Corrected the typings for test-runner user config `testFramework` option
## 0.10.21
### Patch Changes
- d4f92e25: Replace uuid dependency with nanoid
- a09282b4: Replace chalk with nanocolors
- Updated dependencies [a09282b4]
- @web/dev-server-core@0.3.16
## 0.10.20
### Patch Changes
- fcb8af58: Move Babel types to the correct package
## 0.10.19
### Patch Changes
- 73681b6d: Allow user config to be partial
## 0.10.18
### Patch Changes
- 51de0db1: fix(test-runner): fix error when merging multiple test-suites falsely reporting covered branches as uncovered
## 0.10.17
### Patch Changes
- 6f80be68: fix(test-runner): fix error when function metadata varies between tests, as seen in [https://github.com/modernweb-dev/web/issues/689](https://github.com/modernweb-dev/web/issues/689) and [https://github.com/istanbuljs/v8-to-istanbul/issues/121](https://github.com/istanbuljs/v8-to-istanbul/issues/121).
## 0.10.16
### Patch Changes
- e7efd5b7: use script origin to connect websocket
- Updated dependencies [e7efd5b7]
- @web/dev-server-core@0.3.12
## 0.10.15
### Patch Changes
- 6c5893cc: use unescaped import specifier
- Updated dependencies [6c5893cc]
- @web/dev-server-core@0.3.11
## 0.10.14
### Patch Changes
- ce90c7c3: Add the `sendKeys` command
Sends a string of keys for the browser to press (all at once, as with single keys
or shortcuts; e.g. `{press: 'Tab'}` or `{press: 'Shift+a'}` or
`{press: 'Option+ArrowUp}`) or type (in sequence, e.g. `{type: 'Your name'}`) natively.
For specific documentation of the strings to leverage here, see the Playwright documentation,
here:
- `press`: https://playwright.dev/docs/api/class-keyboard#keyboardpresskey-options
- `type`: https://playwright.dev/docs/api/class-keyboard#keyboardtypetext-options
Or, the Puppeter documentation, here:
- `press`: https://pptr.dev/#?product=Puppeteer&show=api-keyboardpresskey-options
- `type`: https://pptr.dev/#?product=Puppeteer&show=api-keyboardtypetext-options
@param payload An object including a `press` or `type` property an the associated string
for the browser runner to apply via that input method.
@example
```ts
await sendKeys({
press: 'Tab',
});
```
@example
```ts
await sendKeys({
type: 'Your address',
});
```
## 0.10.13
### Patch Changes
- b146365a: Add `buildCache` option to the visual regression config to support always saving the "current" screenshot.
Make the `update` option in the visual regression config _strict_, and only save "current" shots as "baseline" when it is set to `true`.
## 0.10.12
### Patch Changes
- 826def7d: Move @types devDependencies to dependencies since user's TSC will also lint libs, therefore these types have to be installed for them.
## 0.10.11
### Patch Changes
- 83750cd2: fallback to fetch on IE11
- Updated dependencies [83750cd2]
- Updated dependencies [096fe25f]
- @web/dev-server-core@0.3.6
## 0.10.10
### Patch Changes
- 2c223cf0: filter server stream errors
- Updated dependencies [2c223cf0]
- @web/dev-server-core@0.3.5
## 0.10.9
### Patch Changes
- 3885b33e: configure timeout for fetching source maps for code coverage
## 0.10.8
### Patch Changes
- 83e0757e: handle cases when userAgent is not defined
## 0.10.7
### Patch Changes
- 6a62b4ee: filter out internal stack traces
- Updated dependencies [6a62b4ee]
- @web/browser-logs@0.2.1
## 0.10.6
### Patch Changes
- 8861ded8: feat(dev-server-core): share websocket instances with iframe parent
- Updated dependencies [8861ded8]
- @web/dev-server-core@0.3.4
## 0.10.5
### Patch Changes
- ad815710: fetch source map from server when generating code coverage reports. this fixes errors when using build tools that generate source maps on the fly, which don't exist on the file system
- c4738a40: support non-inline source maps for stack traces
## 0.10.4
### Patch Changes
- 43bc451c: add configuration option reporters in coverageConfig to use various istanbul reporters
- fd831b54: fix manual testing HTML tests
## 0.10.3
### Patch Changes
- 8e3b1128: fix regression introduced in filterBrowserLogs function that flipped the return value. returning true now properly includes the logs
- d5a5f2bf: Add undeclared dependencies
## 0.10.2
### Patch Changes
- 66638204: deduplicate parallel source map requests
## 0.10.1
### Patch Changes
- 9f1a8a56: normalize test framework path in stack trace
## 0.10.0
### Minor Changes
- 1dd7cd0e: improve serialization of stack traces cross-browser
this adds two breaking changes, which should not affect most users:
- removed `userAgent` field from `TestSession`
- test reporter `reportTestFileResults` is no longer async
- a7d74fdc: drop support for node v10 and v11
### Patch Changes
- Updated dependencies [1dd7cd0e]
- Updated dependencies [1dd7cd0e]
- @web/dev-server-core@0.3.3
- @web/browser-logs@0.2.0
## 0.9.3
### Patch Changes
- f2a84204: reduce delay when clearing terminal between test runs
## 0.9.2
### Patch Changes
- af9811e2: regenerate MJS entrypoint
## 0.9.1
### Patch Changes
- eceb6295: match dotfiles when resolving mimetypes
- Updated dependencies [eceb6295]
- @web/dev-server-core@0.3.1
## 0.9.0
### Minor Changes
- 6e313c18: merged @web/test-runner-cli package into @web/test-runner
- 0f613e0e: handle modules resolved outside root dir
### Patch Changes
- Updated dependencies [0f613e0e]
- @web/dev-server-core@0.3.0
## 0.8.12
### Patch Changes
- 836abc0: handle errors thrown when (de)serializing browser logs
- Updated dependencies [836abc0]
- Updated dependencies [f6107a4]
- @web/browser-logs@0.1.6
## 0.8.11
### Patch Changes
- 2278a95: bump dependencies
## 0.8.10
### Patch Changes
- 931fde9: clean up displayed test file path
- Updated dependencies [3b1a6cc]
- @web/browser-logs@0.1.5
## 0.8.9
### Patch Changes
- 0f0d474: track manual test session imports
## 0.8.8
### Patch Changes
- 4bbaa21: use consistent paths on windows
## 0.8.7
### Patch Changes
- 145a8e6: correctly encode/decode test framework url
## 0.8.6
### Patch Changes
- 304558e: fix(test-runner): deduplicated browsers when reporting
## 0.8.5
### Patch Changes
- 4edf123: added option to configure test runner HTML per group
- cd8928b: separate reporting per browser launcher
## 0.8.4
### Patch Changes
- aadf0fe: Speed up test loading by inling test config and preloading test files.
## 0.8.3
### Patch Changes
- c256a08: allow configuring concurrency per browser launcher
## 0.8.2
### Patch Changes
- 859008b: added experimental mode to test workflows where tests on firefox require the browser window to be focused
## 0.8.1
### Patch Changes
- 175b124: fixed reporting multiple test files for a browser
## 0.8.0
### Minor Changes
- 2291ca1: replaced HTTP with websocket for server-browser communication
this improves test speed, especially when a test file makes a lot of concurrent requests
it lets us us catch more errors during test execution, and makes us catch them faster
### Patch Changes
- Updated dependencies [2291ca1]
- @web/dev-server-core@0.2.11
## 0.7.23
### Patch Changes
- 72ffcde: improve error message when no browsers are configured
- fcc2e28: added manual testing and open browser options
## 0.7.22
### Patch Changes
- bd27fff: improve browser and proxy close logic
## 0.7.21
### Patch Changes
- c8abc29: fix generating manual debug page
## 0.7.20
### Patch Changes
- d15ffee: serve iframe page with HTML content-type
## 0.7.19
### Patch Changes
- 88cc7ac: Reworked concurrent scheduling logic
When running tests in multiple browsers, the browsers are no longer all started in parallel. Instead a new `concurrentBrowsers` property controls how many browsers are run concurrently. This helps improve speed and stability.
## 0.7.18
### Patch Changes
- 34efaad: added support for config groups
## 0.7.17
### Patch Changes
- 4ac0b3a: added experimental iframes mode to test improve speed when testing with selenium
## 0.7.16
### Patch Changes
- 534e92c: added the ability to transform test file imports
## 0.7.15
### Patch Changes
- cde5d29: add browser logging for all browser launchers
- cde5d29: add filterBrowserLogs option
## 0.7.14
### Patch Changes
- 3c72bdd: fixed serving test files outside cwd
## 0.7.13
### Patch Changes
- ab97aa8: publish browser folder
## 0.7.12
### Patch Changes
- 123c0c0: don't serve compressed files
- Updated dependencies [123c0c0]
- @web/dev-server-core@0.2.9
## 0.7.11
### Patch Changes
- 5ba52dd: properly close server on exit
- Updated dependencies [5ba52dd]
- Updated dependencies [8199b68]
- @web/dev-server-core@0.2.8
## 0.7.10
### Patch Changes
- be3c9ed: track and log page reloads
## 0.7.9
### Patch Changes
- 431ec8f: added support for manually debugging in a browser
## 0.7.8
### Patch Changes
- 43cd03b: increased browser start timeout
## 0.7.7
### Patch Changes
- b1306c9: fixed race condition caching headers
- Updated dependencies [b1306c9]
- @web/dev-server-core@0.2.7
## 0.7.6
### Patch Changes
- ee8c8d1: improved handling of timeouts starting or stopping a page
- e3e6b22: removed usage of deepmerge
## 0.7.5
### Patch Changes
- cd1213e: improved logging of resolving outside root dir
- Updated dependencies [cd1213e]
- @web/dev-server-core@0.2.6
## 0.7.4
### Patch Changes
- bc1741d: expose getHtmlPath function
- Updated dependencies [bc1741d]
- @web/dev-server-core@0.2.2
## 0.7.3
### Patch Changes
- 74bbffe: implemented import maps plugin
## 0.7.2
### Patch Changes
- 5f26788: add packages from test-runner-server
- Updated dependencies [5f26788]
- @web/test-runner-core@0.7.2
## 0.7.1
### Patch Changes
- aa65fd1: run build before publishing
## 0.7.0
### Minor Changes
- cdddf68: Removed support for `@web/test-runner-helpers`. This is a breaking change, the functionality is now available in `@web/test-runner-commands`.
- fdcf2e5: Merged test runner server into core, and made it no longer possible configure a different server.
The test runner relies on the server for many things, merging it into core makes the code more maintainable. The server is composable, you can proxy requests to other servers and we can look into adding more composition APIs later.
- 9be1f95: Added native node es module entrypoints. This is a breaking change. Before, native node es module imports would import a CJS module as a default import and require destructuring afterwards:
```js
import playwrightModule from '@web/test-runner-playwright';
const { playwrightLauncher } = playwrightModule;
```
Now, the exports are only available directly as a named export:
```js
import { playwrightLauncher } from '@web/test-runner-playwright';
```
### Patch Changes
- 62ff8b2: make tests work on windows
## 0.6.23
### Patch Changes
- d77093b: allow code coverage instrumentation through JS
## 0.6.22
### Patch Changes
- 02a3926: expose browser name from BrowserLauncher
- 74cc129: implement commands API
## 0.6.21
### Patch Changes
- cbdf3c7: chore: merge browser lib into test-runner-core
## 0.6.20
### Patch Changes
- c6fb524: expose test suite hierarchy, passed tests and duration
## 0.6.19
### Patch Changes
- 432f090: expose browser name from BrowserLauncher
- 5b36825: prevent debug sessions from interferring with regular test sessions
## 0.6.18
### Patch Changes
- 736d101: improve scheduling logic and error handling
## 0.6.17
### Patch Changes
- 3757865: add more args to test reporter callbacks
## 0.6.16
### Patch Changes
- 5fada4a: improve logging and error reporting
## 0.6.15
### Patch Changes
- 8596276: move logger to test runner cli
## 0.6.14
### Patch Changes
- 023cc3f: don't require selecting files when there is only one test file
## 0.6.13
### Patch Changes
- e97d492: allow adding custom reporters
## 0.6.12
### Patch Changes
- 27a91cc: allow configuring test framework options
## 0.6.11
### Patch Changes
- f991708: encode source map url requests
## 0.6.10
### Patch Changes
- 1ebbf4a: fix deep cloning causing slow coverage measurements
## 0.6.9
### Patch Changes
- db5baff: cleanup and sort dependencies
## 0.6.8
### Patch Changes
- 687089f: support source maps in error stack traces
## 0.6.7
### Patch Changes
- c72ea22: allow configuring browser launch options
## 0.6.6
### Patch Changes
- 4a6b9c2: make coverage work in watch mode
## 0.6.5
### Patch Changes
- 1d6d498: allow changing viewport in tests
## 0.6.4
### Patch Changes
- 5ab18d8: feat(test-runner-core): batch v8 test coverage
## 0.6.3
### Patch Changes
- a9603b5: fix merging v8 code coverage
## 0.6.2
### Patch Changes
- 3dab600: profile test coverage through v8/chromium
## 0.6.1
### Patch Changes
- d1e9bec: emit test run finished after session update
## 0.6.0
### Minor Changes
- c4cb321: Use web dev server in test runner. This contains multiple breaking changes:
- Browsers that don't support es modules are not supported for now. We will add this back later.
- Most es-dev-server config options are no longer available. The only options that are kept are `plugins`, `middleware`, `nodeResolve` and `preserveSymlinks`.
- Test runner config changes:
- Dev server options are not available on the root level of the configuration file.
- `nodeResolve` is no longer enabled by default. You can enable it with the `--node-resolve` flag or `nodeResolve` option.
- `middlewares` option is now called `middleware`.
- `testFrameworkImport` is now called `testFramework`.
- `address` is now split into `protocol` and `hostname`.
## 0.5.7
### Patch Changes
- 50d1036: reset request 404s on rerun
## 0.5.6
### Patch Changes
- 14b7fae: handle errors in mocha hooks
## 0.5.5
### Patch Changes
- 56ed519: open browser windows sequentially in selenium
## 0.5.4
### Patch Changes
- ebfdfd2: add selenium browser launcher
## 0.5.3
### Patch Changes
- 64d867c: don't schedule sessions in parallel
## 0.5.2
### Patch Changes
- f5eff91: clear timeouts on close
## 0.5.1
### Patch Changes
- 45a2f21: add ability to run HTML tests
## 0.5.0
### Minor Changes
- 1d277e9: rename framework to browser-lib
## 0.4.0
### Minor Changes
- ccb63df: @web/test-runner-dev-server to @web/test-runner-server
## 0.3.0
### Minor Changes
- 0c83d7e: create separate coverage and coverageConfig options
## 0.2.6
### Patch Changes
- 4d0d854: write test coverage details
## 0.2.5
### Patch Changes
- 115442b: add readme, package tags and description
## 0.2.4
### Patch Changes
- 444ee32: support multiple browser launchers
## 0.2.3
### Patch Changes
- 5a88530: merge TestSession and TestSessionResult
## 0.2.2
### Patch Changes
- e30036b: remove console statement
## 0.2.1
### Patch Changes
- ce0798f: report opening debug browser
## 0.2.0
### Minor Changes
- 37eb13a: don't wait for browser to close
## 0.1.2
### Patch Changes
- 692bf8d: Export constants
## 0.1.1
### Patch Changes
- 7260dad: update build script
## 0.1.0
### Minor Changes
- 45c8e3d: First release
| modernweb-dev/web/packages/test-runner-core/CHANGELOG.md/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-core/CHANGELOG.md",
"repo_id": "modernweb-dev",
"token_count": 6367
} | 221 |
import reports from 'istanbul-reports';
import libReport from 'istanbul-lib-report';
import { CoverageConfig } from '../config/TestRunnerCoreConfig';
import { TestCoverage } from '../coverage/getTestCoverage';
export function writeCoverageReport(testCoverage: TestCoverage, config: CoverageConfig) {
// create a context for report generation
const context = libReport.createContext({
dir: config.reportDir,
watermarks: {
statements: [50, 80],
functions: [50, 80],
branches: [50, 80],
lines: [50, 80],
},
coverageMap: testCoverage.coverageMap,
});
const reporters = config.reporters || [];
for (const reporter of reporters) {
const report = reports.create(reporter, {
projectRoot: process.cwd(),
maxCols: process.stdout.columns || 100,
});
(report as any).execute(context);
}
}
| modernweb-dev/web/packages/test-runner-core/src/cli/writeCoverageReport.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-core/src/cli/writeCoverageReport.ts",
"repo_id": "modernweb-dev",
"token_count": 289
} | 222 |
import { Middleware } from '@web/dev-server-core';
import path from 'path';
export function cacheMiddleware(cachedPatterns: string[], watch: boolean): Middleware {
return async (context, next) => {
await next();
if (
path.extname(context.path) &&
(!watch || cachedPatterns.some(pattern => context.path.includes(pattern)))
) {
context.response.set('cache-control', 'public, max-age=31536000');
}
};
}
| modernweb-dev/web/packages/test-runner-core/src/server/middleware/cacheMiddleware.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-core/src/server/middleware/cacheMiddleware.ts",
"repo_id": "modernweb-dev",
"token_count": 155
} | 223 |
import { BrowserLauncher } from '../browser-launcher/BrowserLauncher';
import { TestRunnerCoreConfig } from '../config/TestRunnerCoreConfig';
import { TestRunnerGroupConfig } from '../config/TestRunnerGroupConfig';
export interface TestSessionGroup {
name: string;
testFiles: string[];
browsers: BrowserLauncher[];
sessionIds: string[];
testRunnerHtml?: (
testRunnerImport: string,
config: TestRunnerCoreConfig,
group: TestRunnerGroupConfig,
) => string;
}
| modernweb-dev/web/packages/test-runner-core/src/test-session/TestSessionGroup.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-core/src/test-session/TestSessionGroup.ts",
"repo_id": "modernweb-dev",
"token_count": 143
} | 224 |
# Test Runner Mocha
Test framework implementation of [Mocha](https://mochajs.org/) for web test runner.
See [our website](https://modern-web.dev/docs/test-runner/test-frameworks/mocha/) for full documentation.
| modernweb-dev/web/packages/test-runner-mocha/README.md/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-mocha/README.md",
"repo_id": "modernweb-dev",
"token_count": 65
} | 225 |
/**
* Import a mockable version of a module to change its implementation.
* @param {string} moduleSpecifier The specifier of the module. Bare module specifiers and server relative specifiers are supported. Regular relative paths are not supported
* @returns {Promise<Record<string, func> | void >} Object with reassignable properties that match every export of the specified module.
* If the specified module contains a default export, the export will be available from the `default` property. Only function expressions are supported when rewiring default exports.
*/
export function importMockable(moduleSpecifier: string): Promise<Record<string, func> | void>;
| modernweb-dev/web/packages/test-runner-module-mocking/browser/index.d.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-module-mocking/browser/index.d.ts",
"repo_id": "modernweb-dev",
"token_count": 149
} | 226 |
import { getCurrentHour } from './time-library.js';
export function getTimeOfDay() {
const hour = getCurrentHour();
if (hour < 6 || hour > 18) {
return 'night';
}
return 'day';
}
| modernweb-dev/web/packages/test-runner-module-mocking/test/fixtures/server-relative/fixture/getTimeOfDay.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-module-mocking/test/fixtures/server-relative/fixture/getTimeOfDay.js",
"repo_id": "modernweb-dev",
"token_count": 67
} | 227 |
# Test runner selenium
Run tests using [selenium-webdriver](https://www.npmjs.com/package/selenium-webdriver).
See [our website](https://modern-web.dev/docs/test-runner/browser-launchers/selenium/) for full documentation.
| modernweb-dev/web/packages/test-runner-selenium/README.md/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-selenium/README.md",
"repo_id": "modernweb-dev",
"token_count": 70
} | 228 |
// this file is autogenerated with the generate-mjs-dts-entrypoints script
import cjsEntrypoint from './dist/index.js';
const { visualRegressionPlugin } = cjsEntrypoint;
export { visualRegressionPlugin };
| modernweb-dev/web/packages/test-runner-visual-regression/plugin.mjs/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-visual-regression/plugin.mjs",
"repo_id": "modernweb-dev",
"token_count": 61
} | 229 |
import path from 'path';
import { runTests } from '@web/test-runner-core/test-helpers';
import { expect } from 'chai';
import { chromeLauncher } from '@web/test-runner-chrome';
import { visualRegressionPlugin } from '../src/visualRegressionPlugin.js';
import { fileExists } from '../src/fs.js';
import { playwrightLauncher } from '@web/test-runner-playwright';
describe('visualRegressionPlugin', function test() {
this.timeout(20000);
it('can run a passing test', async () => {
await runTests({
files: [path.join(__dirname, 'diff-pass-test.js')],
browsers: [
chromeLauncher(),
playwrightLauncher({ product: 'firefox' }),
playwrightLauncher({ product: 'webkit' }),
],
plugins: [
{
name: 'resolve-commands',
resolveImport({ source }) {
if (source === '@web/test-runner-commands') {
return '/packages/test-runner-commands/browser/commands.mjs';
}
},
},
visualRegressionPlugin({
baseDir: 'screenshots',
update: process.argv.includes('--update-visual-diffs'),
}),
],
});
});
it('can run a failed test', async () => {
const { sessions } = await runTests(
{
files: [path.join(__dirname, 'diff-fail-test.js')],
browsers: [
chromeLauncher(),
playwrightLauncher({ product: 'firefox' }),
playwrightLauncher({ product: 'webkit' }),
],
plugins: [
{
name: 'resolve-commands',
resolveImport({ source }) {
if (source === '@web/test-runner-commands') {
return '/packages/test-runner-commands/browser/commands.mjs';
}
},
},
visualRegressionPlugin({
baseDir: 'screenshots',
update: process.argv.includes('--update-visual-diffs'),
}),
],
},
[],
{ allowFailure: true, reportErrors: false },
);
expect(sessions.length).to.equal(3);
for (const session of sessions) {
expect(session.passed).to.equal(false);
expect(session.testResults!.tests.length).to.equal(1);
expect(session.testResults!.tests[0].error!.message).to.include(
'Visual diff failed. New screenshot is ',
);
expect(
await fileExists(
path.resolve(
__dirname,
'..',
'screenshots',
session.browser.name,
'failed',
'my-failed-element.png',
),
),
).to.equal(true);
expect(
await fileExists(
path.resolve(
__dirname,
'..',
'screenshots',
session.browser.name,
'failed',
'my-failed-element-diff.png',
),
),
).to.equal(true);
}
});
});
| modernweb-dev/web/packages/test-runner-visual-regression/test/visualRegressionPlugin.test.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner-visual-regression/test/visualRegressionPlugin.test.ts",
"repo_id": "modernweb-dev",
"token_count": 1388
} | 230 |
import { fromRollup } from '@web/dev-server-rollup';
import * as babelModule from '@rollup/plugin-babel';
const babel = fromRollup(babelModule.babel);
export default /** @type {import('@web/test-runner').TestRunnerConfig} */ ({
nodeResolve: true,
files: ['demo/coverage-babel/test/**/*.test.js'],
coverage: true,
coverageConfig: {
nativeInstrumentation: false,
},
plugins: [
babel({
// avoid running babel on code that doesn't need it
include: ['**/*/src/**/*.js'],
babelHelpers: 'bundled',
plugins: ['babel-plugin-istanbul'],
}),
],
});
| modernweb-dev/web/packages/test-runner/demo/coverage-babel/config.mjs/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/coverage-babel/config.mjs",
"repo_id": "modernweb-dev",
"token_count": 228
} | 231 |
export function a() {
throw new Error('error thrown in a.js')
} | modernweb-dev/web/packages/test-runner/demo/source-maps/bundled/src/a.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/source-maps/bundled/src/a.js",
"repo_id": "modernweb-dev",
"token_count": 20
} | 232 |
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var MyClass = /** @class */ (function () {
function MyClass() {
}
MyClass.prototype.doFoo = function (foo, bar) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, Promise.resolve()];
case 1:
_a.sent();
foo.nonExisting();
return [2 /*return*/, new Promise(function (resolve) {
resolve();
})];
}
});
});
};
return MyClass;
}());
export { MyClass };
export function doBar(bar, foo) {
throw new Error('undefined is a function');
}
//# sourceMappingURL=MyClass.js.map | modernweb-dev/web/packages/test-runner/demo/source-maps/virtual/virtual-files/MyClass.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/source-maps/virtual/virtual-files/MyClass.js",
"repo_id": "modernweb-dev",
"token_count": 1600
} | 233 |
import { expect } from './chai.js';
import './fail-error-module-exec.js';
it('test 1', () => {
expect(true).to.be.true;
});
| modernweb-dev/web/packages/test-runner/demo/test/fail-error-module-exec.test.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/test/fail-error-module-exec.test.js",
"repo_id": "modernweb-dev",
"token_count": 51
} | 234 |
export default {
name: 'group-b',
files: 'b.test.js',
};
| modernweb-dev/web/packages/test-runner/demo/test/groups/b.test.config.mjs/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/test/groups/b.test.config.mjs",
"repo_id": "modernweb-dev",
"token_count": 26
} | 235 |
module.exports = {
rootDir: '../..',
files: ['demo/test/mocha-options/a.test.js'],
testFramework: {
config: { ui: 'tdd' },
},
};
| modernweb-dev/web/packages/test-runner/demo/test/mocha-options/config.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/test/mocha-options/config.js",
"repo_id": "modernweb-dev",
"token_count": 66
} | 236 |
import { expect } from './chai.js';
it('test 404 request', async () => {
try {
await fetch('/non-existing.png');
} catch {}
expect(true).to.be.true;
});
| modernweb-dev/web/packages/test-runner/demo/test/pass-404-request.test.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/test/pass-404-request.test.js",
"repo_id": "modernweb-dev",
"token_count": 62
} | 237 |
import './shared-a.js';
for (let i = 0; i < 5; i += 1) {
it(`test ${i}`, async () => {
// await new Promise((r) => setTimeout(r, Math.floor(Math.random() * 200) + 200));
});
}
| modernweb-dev/web/packages/test-runner/demo/test/pass-slow.test.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/test/pass-slow.test.js",
"repo_id": "modernweb-dev",
"token_count": 78
} | 238 |
export { expect } from '@esm-bundle/chai';
//# sourceMappingURL=chai.js.map | modernweb-dev/web/packages/test-runner/demo/tsc/dist/test/chai.js/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/tsc/dist/test/chai.js",
"repo_id": "modernweb-dev",
"token_count": 29
} | 239 |
import './shared-a.js';
| modernweb-dev/web/packages/test-runner/demo/tsc/dist/test/pass-18.test.d.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/tsc/dist/test/pass-18.test.d.ts",
"repo_id": "modernweb-dev",
"token_count": 10
} | 240 |
{
"compilerOptions": {
"target": "es2018",
"module": "esnext",
"moduleResolution": "node",
"noEmitOnError": true,
"lib": ["es2017", "dom"],
"strict": true,
"esModuleInterop": false,
"allowSyntheticDefaultImports": true,
"experimentalDecorators": true,
"importHelpers": true,
"outDir": "dist",
"sourceMap": true,
"inlineSources": true,
"rootDir": "./",
"declaration": true,
"skipLibCheck": true
},
"include": ["**/*.ts"]
}
| modernweb-dev/web/packages/test-runner/demo/tsc/tsconfig.json/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/demo/tsc/tsconfig.json",
"repo_id": "modernweb-dev",
"token_count": 210
} | 241 |
import type { Reporter, ReporterArgs, TestSuiteResult } from '@web/test-runner-core';
import { reportTestsErrors } from './reportTestsErrors.js';
import { reportTestFileErrors } from './reportTestFileErrors.js';
import { TestRunnerLogger } from '../logger/TestRunnerLogger.js';
const color =
([x, y]: [number, number]) =>
(z: string) =>
`\x1b[${x}m${z}\x1b[${y}m${reset}`;
const reset = `\x1b[0m\x1b[0m`;
const red = color([31, 89]);
/** Test reporter that summarizes all test for a given run using dot notation */
export function dotReporter(): Reporter {
let args: ReporterArgs;
let favoriteBrowser: string;
const logger = new TestRunnerLogger();
function log(passed: boolean) {
logger.log(passed ? '.' : red('x'));
}
function logResults(results?: TestSuiteResult) {
for (const result of results?.tests ?? []) {
log(result.passed);
}
for (const suite of results?.suites ?? []) {
logSuite(suite);
}
}
function logSuite(suite: TestSuiteResult) {
logResults(suite);
}
return {
start(_args) {
args = _args;
favoriteBrowser =
args.browserNames.find(name => {
const n = name.toLowerCase();
return n.includes('chrome') || n.includes('chromium') || n.includes('firefox');
}) ?? args.browserNames[0];
},
reportTestFileResults({ sessionsForTestFile: sessions }) {
for (const session of sessions) {
logResults(session.testResults);
}
},
onTestRunFinished({ sessions }) {
const failedSessions = sessions.filter(s => !s.passed);
if (failedSessions.length > 0) {
logger.log('\n\nErrors Reported in Tests:\n\n');
reportTestsErrors(logger, args.browserNames, favoriteBrowser, failedSessions);
reportTestFileErrors(logger, args.browserNames, favoriteBrowser, failedSessions, true);
}
},
};
}
| modernweb-dev/web/packages/test-runner/src/reporter/dotReporter.ts/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/src/reporter/dotReporter.ts",
"repo_id": "modernweb-dev",
"token_count": 718
} | 242 |
// Don't edit this file directly. It is generated by generate-ts-configs script
{
"extends": "../../tsconfig.node-base.json",
"compilerOptions": {
"module": "commonjs",
"outDir": "./dist",
"rootDir": "./src",
"composite": true,
"allowJs": true
},
"references": [
{
"path": "../parse5-utils/tsconfig.json"
},
{
"path": "../browser-logs/tsconfig.json"
},
{
"path": "../dev-server-core/tsconfig.json"
},
{
"path": "../test-runner-core/tsconfig.json"
},
{
"path": "../test-runner-coverage-v8/tsconfig.json"
},
{
"path": "../test-runner-mocha/tsconfig.json"
},
{
"path": "../test-runner-chrome/tsconfig.json"
},
{
"path": "../config-loader/tsconfig.json"
},
{
"path": "../dev-server-rollup/tsconfig.json"
},
{
"path": "../test-runner-playwright/tsconfig.json"
},
{
"path": "../test-runner-webdriver/tsconfig.json"
},
{
"path": "../polyfills-loader/tsconfig.json"
},
{
"path": "../dev-server-esbuild/tsconfig.json"
},
{
"path": "../dev-server-legacy/tsconfig.json"
},
{
"path": "../dev-server/tsconfig.json"
},
{
"path": "../test-runner-commands/tsconfig.json"
},
{
"path": "../test-runner-saucelabs/tsconfig.json"
}
],
"include": [
"src",
"types"
],
"exclude": [
"src/browser",
"tests",
"dist"
]
} | modernweb-dev/web/packages/test-runner/tsconfig.json/0 | {
"file_path": "modernweb-dev/web/packages/test-runner/tsconfig.json",
"repo_id": "modernweb-dev",
"token_count": 727
} | 243 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<path fill="#006a4e" d="M0 0h640v480H0z"/>
<circle cx="280" cy="240" r="160" fill="#f42a41"/>
</svg>
| odota/web/public/assets/images/flags/bd.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/bd.svg",
"repo_id": "odota",
"token_count": 89
} | 244 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<g fill-rule="evenodd">
<path fill="#00cbff" d="M0 0h640v480H0z"/>
<path fill="#fff" d="M0 160h640v160H0z"/>
<path fill="#000" d="M0 185.97h640v108.05H0z"/>
</g>
</svg>
| odota/web/public/assets/images/flags/bw.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/bw.svg",
"repo_id": "odota",
"token_count": 133
} | 245 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<defs>
<clipPath id="a">
<path fill-opacity=".67" d="M-32 0h682.67v512H-32z"/>
</clipPath>
</defs>
<g fill-rule="evenodd" clip-path="url(#a)" transform="translate(30) scale(.94)">
<path fill="#0050f0" d="M-32 0h768v512H-32z"/>
<path fill="#fff" d="M-32 102.4h768v102.4H-32zm0 204.8h768v102.4H-32z"/>
<path d="M-32 0l440.69 255.67L-32 511.01V0z" fill="#ed0000"/>
<path d="M161.75 325.47l-47.447-35.432-47.214 35.78 17.56-58.144-47.13-35.904 58.306-.5 18.084-57.97 18.472 57.836 58.305.077-46.886 36.243 17.948 58.016z" fill="#fff"/>
</g>
</svg>
| odota/web/public/assets/images/flags/cu.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/cu.svg",
"repo_id": "odota",
"token_count": 344
} | 246 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<defs>
<clipPath id="a">
<path fill-opacity=".67" d="M-85.333 0h682.67v512h-682.67z"/>
</clipPath>
</defs>
<g clip-path="url(#a)" transform="translate(80) scale(.94)">
<g stroke-width="1pt">
<path fill="#006" d="M-256 0H768.02v512.01H-256z"/>
<path d="M-256 0v57.244l909.535 454.768H768.02V454.77L-141.515 0H-256zM768.02 0v57.243L-141.515 512.01H-256v-57.243L653.535 0H768.02z" fill="#fff"/>
<path d="M170.675 0v512.01h170.67V0h-170.67zM-256 170.67v170.67H768.02V170.67H-256z" fill="#fff"/>
<path d="M-256 204.804v102.402H768.02V204.804H-256zM204.81 0v512.01h102.4V0h-102.4zM-256 512.01L85.34 341.34h76.324l-341.34 170.67H-256zM-256 0L85.34 170.67H9.016L-256 38.164V0zm606.356 170.67L691.696 0h76.324L426.68 170.67h-76.324zM768.02 512.01L426.68 341.34h76.324L768.02 473.848v38.162z" fill="#c00"/>
</g>
</g>
</svg>
| odota/web/public/assets/images/flags/gb.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/gb.svg",
"repo_id": "odota",
"token_count": 507
} | 247 |
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="480" width="640" viewBox="0 0 640 480">
<path fill="#ce1126" d="M0 0h320v480H0z"/>
<path fill="#fcd116" d="M320 0h320v240H320z"/>
<path fill="#009e49" d="M320 240h320v240H320z"/>
<g id="b" transform="matrix(80 0 0 80 160 240)">
<path id="a" d="M0-1v1h.5" transform="rotate(18 0 -1)"/>
<use height="100%" width="100%" xlink:href="#a" transform="scale(-1 1)"/>
</g>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(72 160 240)"/>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(144 160 240)"/>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(-144 160 240)"/>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(-72 160 240)"/>
</svg>
| odota/web/public/assets/images/flags/gw.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/gw.svg",
"repo_id": "odota",
"token_count": 335
} | 248 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<defs>
<clipPath id="a">
<path fill-opacity=".67" d="M0 0h640v480H0z"/>
</clipPath>
</defs>
<g fill-rule="evenodd" stroke-width="0" clip-path="url(#a)">
<path fill="#003897" d="M0 0h666.67v480H0z"/>
<path d="M0 186.67h186.67V0h106.67v186.67h373.33v106.67H293.34v186.67H186.67V293.34H0V186.67z" fill="#fff"/>
<path d="M0 213.33h213.33V0h53.333v213.33h400v53.333h-400v213.33H213.33v-213.33H0V213.33z" fill="#d72828"/>
</g>
</svg>
| odota/web/public/assets/images/flags/is.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/is.svg",
"repo_id": "odota",
"token_count": 287
} | 249 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<g fill-rule="evenodd" stroke-width="1pt">
<path fill="#fff" d="M0 0h640v480H0z"/>
<path fill="#00267f" d="M0 0h213.337v480H0z"/>
<path fill="#f31830" d="M426.662 0H640v480H426.662z"/>
</g>
</svg>
| odota/web/public/assets/images/flags/mf.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/mf.svg",
"repo_id": "odota",
"token_count": 144
} | 250 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<defs>
<clipPath id="a">
<path fill-opacity=".67" d="M0 0h640v480H0z"/>
</clipPath>
</defs>
<g clip-path="url(#a)">
<path fill="#fff" d="M0 0h640v480H0z"/>
<path fill-rule="evenodd" fill="#fff" d="M92.462 0h477.19v480H92.462z"/>
<path fill-rule="evenodd" fill="#db0000" d="M323.07 3.655h358v221.68h-358z"/>
<path fill-rule="evenodd" fill="#0000ab" d="M3.227 225.33h319.87v254.66H3.227zM214.8 177.65l-41.959-29.326-41.754 29.614 15.529-48.124-41.677-29.716 51.562-.414 15.993-47.978 16.335 47.867 51.562.063-41.463 29.996 15.872 48.017z"/>
<path d="M516.85 413.89l-42.354-27.744-42.146 28.017 15.675-45.529-42.069-28.114 52.047-.392 16.143-45.391 16.489 45.286 52.047.06-41.853 28.379 16.021 45.428z" fill-rule="evenodd" fill="#d80000"/>
</g>
</svg>
| odota/web/public/assets/images/flags/pa.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/pa.svg",
"repo_id": "odota",
"token_count": 439
} | 251 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<g fill-rule="evenodd" stroke-width="1pt">
<path fill="#00319c" d="M0 0h213.333v480H0z"/>
<path fill="#ffde00" d="M213.333 0h213.333v480H213.333z"/>
<path fill="#de2110" d="M426.666 0H640v480H426.666z"/>
</g>
</svg>
| odota/web/public/assets/images/flags/ro.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/ro.svg",
"repo_id": "odota",
"token_count": 152
} | 252 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<g fill-rule="evenodd" stroke-width="1pt">
<path fill="#0b7226" d="M-.006 0h213.328v480H-.006z"/>
<path fill="#ff0" d="M213.322 0H426.65v480H213.322z"/>
<path fill="#bc0000" d="M426.65 0h213.328v480H426.65z"/>
</g>
<path fill="#0b7226" d="M342.047 218.852h71.73l-56.627 43.556 20.762 69.314-56.627-43.569-56.627 41.588 20.762-67.333-56.627-43.556h69.844l22.648-71.295z"/>
</svg>
| odota/web/public/assets/images/flags/sn.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/sn.svg",
"repo_id": "odota",
"token_count": 240
} | 253 |
<svg xmlns="http://www.w3.org/2000/svg" height="480" width="640" viewBox="0 0 640 480">
<defs>
<clipPath id="a">
<path fill-opacity=".67" d="M0 0h682.67v512H0z"/>
</clipPath>
</defs>
<g clip-path="url(#a)" fill-rule="evenodd" transform="scale(.9375)">
<path fill="#cb000f" d="M0 0h1031.2v512H0z"/>
<path d="M0 0c3.234 0 512 256.72 512 256.72L0 512V0z" fill="#f8c00c"/>
<path d="M0 0c2.151 0 340.62 256.72 340.62 256.72L0 512V0z"/>
<path d="M187.71 298.16l-60.813-13.478-31.072 52.839-4.861-59.677-60.753-13.372 54.84-24.817-3.292-59.385 40.235 43.39 55.341-25.232-28.827 53.899 39.203 45.835z" fill="#fff"/>
</g>
</svg>
| odota/web/public/assets/images/flags/tl.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/tl.svg",
"repo_id": "odota",
"token_count": 341
} | 254 |
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" height="480" width="640" viewBox="0 0 640 480">
<path fill="#1eb53a" d="M0 320h640v160H0z"/>
<path fill="#0099b5" d="M0 0h640v160H0z"/>
<path fill="#ce1126" d="M0 153.6h640v172.8H0z"/>
<path fill="#fff" d="M0 163.2h640v153.6H0z"/>
<circle cx="134.4" cy="76.8" r="57.6" fill="#fff"/>
<circle cx="153.6" cy="76.8" r="57.6" fill="#0099b5"/>
<g transform="matrix(1.92 0 0 1.92 261.12 122.88)" fill="#fff">
<g id="e">
<g id="d">
<g id="c">
<g id="b">
<path id="a" d="M0-6L-1.854-.294 1 .633"/>
<use height="100%" width="100%" xlink:href="#a" transform="scale(-1 1)"/>
</g>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(72)"/>
</g>
<use height="100%" width="100%" xlink:href="#b" transform="rotate(-72)"/>
<use height="100%" width="100%" xlink:href="#c" transform="rotate(144)"/>
</g>
<use height="100%" width="100%" xlink:href="#d" y="-24"/>
<use height="100%" width="100%" xlink:href="#d" y="-48"/>
</g>
<use height="100%" width="100%" xlink:href="#e" x="24"/>
<use height="100%" width="100%" xlink:href="#e" x="48"/>
<use height="100%" width="100%" xlink:href="#d" x="-48"/>
<use height="100%" width="100%" xlink:href="#d" x="-24"/>
<use height="100%" width="100%" xlink:href="#d" x="-24" y="-24"/>
</g>
</svg>
| odota/web/public/assets/images/flags/uz.svg/0 | {
"file_path": "odota/web/public/assets/images/flags/uz.svg",
"repo_id": "odota",
"token_count": 706
} | 255 |
const TOGGLE_SHOW_FORM = 'form/TOGGLE_SHOW_FORM';
export const formActions = {
TOGGLE_SHOW_FORM,
};
export const toggleShowForm = formName => ({
type: TOGGLE_SHOW_FORM,
formName,
});
| odota/web/src/actions/formActions.js/0 | {
"file_path": "odota/web/src/actions/formActions.js",
"repo_id": "odota",
"token_count": 78
} | 256 |
import React from 'react';
import styled from 'styled-components';
import PropTypes from 'prop-types';
import constants from '../constants';
import { formatSkillOrAttributeValues } from '../../utility';
const Ability = styled.div`
margin-left: 8px;
color: rgb(176, 198, 212);
max-width: 85%;
.ability-text {
padding: 6px;
font-weight: normal;
color: rgb(169, 181, 193);
text-shadow: 1px 1px black;
}
`;
const AbilityDescription = styled.p`
line-height: 16px;
color: #c8dade;
margin: 0px;
padding: 0px;
font-weight: normal;
`;
const AbilityIcon = styled.img`
border-radius: 4px;
flex-grow: 0;
flex-shrink: 0;
flex-basis: 15%;
opacity: .7;
overflow: hidden;
border: 1px black solid;
height: 42px;
transition: opacity .2s, box-shadow .4s, transform .2s;
&:hover {
opacity: 1;
box-shadow: 0 0 150px rgba(255, 255, 255, .4);
transform: scale(1.1);
}
`;
const AbilityTitle = styled.span`
color: ${constants.textColorPrimary};
text-transform: uppercase;
font-size: 1rem;
`;
const Attributes = styled.div`
margin-top: 4px;
line-height: 16px;
& #footer {
color: #95a5a6;
}
& #value {
font-weight: 500;
}
& #header{
color: #95a5a6;
}
`;
const Body = styled.div`
display: flex;
margin: 10px 9px 10px 9px;
padding: 6px;
font-weight: bold;
color: ${constants.colorBlueGray};
`;
const Break = styled.div`
margin-left: 13px;
margin-right: 13px;
height: 1px;
background-color: #080D15;
`;
const NewAbility = styled.div`
background-color: #335380;
text-transform: uppercase;
color: ${constants.textColorPrimary};
text-align: center;
font-size: 10px;
padding: 0px 6px;
width: 40%;
margin: 4px 0px;
`;
const getAghsAttributes = (skillObject) => {
const skills = (skillObject.attrib || [])
const attributes = skills.map(attrib => (
<div className="attribute" key={attrib.key}>
<span id="header">{attrib.header} </span>
<span id="value">{formatSkillOrAttributeValues(attrib.value)}</span>
<span id="footer"> {attrib.footer || ''}</span>
</div>
))
return (
<>
{attributes}
{skillObject.dmg ? <div className="attribute">DAMAGE: <span id="value">{formatSkillOrAttributeValues(skillObject.dmg)}</span></div> : ''}
</>
)
}
const AghsTooltipBody = ({ icon, skillName, isNewSkill, aghsDescription, skillObject, hasUpgrade }) => (
<Body>
{hasUpgrade ? (
<>
<AbilityIcon src={icon} />
<Ability>
<AbilityTitle>
{skillName}
</AbilityTitle>
<NewAbility>
{isNewSkill ? (<span>New ability</span>) : (<span>Upgrade</span>)}
</NewAbility>
<AbilityDescription>
{aghsDescription}
{skillObject.attrib && skillObject.attrib.length > 0 &&
<div>
<Break />
<Attributes>
{getAghsAttributes(skillObject)}
</Attributes>
</div>
}
</AbilityDescription>
</Ability>
</>
) : (
<span>No Aghanim's upgrade found</span>
)}
</Body>
)
AghsTooltipBody.propTypes = {
icon: PropTypes.string,
skillName: PropTypes.string,
isNewSkill: PropTypes.bool,
aghsDescription: PropTypes.string,
skillObject: PropTypes.shape({}),
hasUpgrade: PropTypes.bool,
}
export default AghsTooltipBody;
| odota/web/src/components/AghsTooltip/AghsTooltipBody.jsx/0 | {
"file_path": "odota/web/src/components/AghsTooltip/AghsTooltipBody.jsx",
"repo_id": "odota",
"token_count": 1460
} | 257 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import CircularProgress from 'material-ui/CircularProgress';
import styled from 'styled-components';
import Spinner from '../Spinner';
import Error from '../Error';
import { IconCheese } from '../Icons';
const ProgressDiv = styled.div`
position: relative;
width: 90px;
height: 90px;
& > div[mode="determinate"],
& div.cheeseDiv {
position: absolute !important;
}
& svg > circle {
stroke-width: 3;
}
&[data-hint] {
&::after {
left: 10px;
right: 10px;
text-align: center;
}
}
`;
const FrontProgress = styled(CircularProgress)`
z-index: 1;
`;
const BackProgress = styled(CircularProgress)`
circle {
stroke: rgba(255, 255, 255, 0.06) !important;
}
`;
const CheeseDiv = styled.div`
top: 17px;
left: 28px;
width: 35px;
height: 35px;
& svg {
filter: drop-shadow(0 0 10px #ff0);
}
`;
const PercentP = styled.p`
text-align: center;
padding: 0 !important;
margin-top: -5px !important;
& > div {
position: relative;
width: 100%;
}
`;
const Cheese = ({ donations = {}, error, loading }) => {
const { goal, cheese } = donations;
const percent = ((cheese / goal) * 100) || 0;
return (
<div>
{error && <Error />}
{loading && <Spinner />}
{!error && !loading &&
<ProgressDiv data-hint={`${cheese} / ${goal}`}>
<FrontProgress mode="determinate" value={Math.min(percent, 100)} size={90} />
<BackProgress mode="determinate" value={100} size={90} />
<CheeseDiv className="cheeseDiv">
<IconCheese />
<PercentP>
{`${percent.toFixed(0)}%`}
</PercentP>
</CheeseDiv>
</ProgressDiv>
}
</div>
);
};
Cheese.propTypes = {
donations: PropTypes.shape({}),
error: PropTypes.string,
loading: PropTypes.bool,
};
const mapStateToProps = (state) => {
const { loading, error } = state.app.metadata;
return {
loading,
error,
donations: state.app.metadata.data.cheese,
};
};
export default connect(mapStateToProps)(Cheese);
| odota/web/src/components/Cheese/CheeseCircle.jsx/0 | {
"file_path": "odota/web/src/components/Cheese/CheeseCircle.jsx",
"repo_id": "odota",
"token_count": 863
} | 258 |
import React from 'react';
import PropTypes from 'prop-types';
import RaisedButton from 'material-ui/RaisedButton';
const ExplorerOutputButton = ({
defaultSelected, label, format, href, download, onClick, context,
}) => {
let clickFn;
if (onClick) {
clickFn = onClick;
} else if (format) {
clickFn = () => {
context.setState({ ...context.state, builder: { ...context.state.builder, format } }, context.syncWindowHistory);
};
} else {
clickFn = noOp => noOp;
}
return (<RaisedButton
secondary={format && ((defaultSelected && !context.state.builder.format) || context.state.builder.format === format)}
style={{ margin: '5px' }}
label={label}
href={href}
download={download}
onClick={clickFn}
/>);
};
ExplorerOutputButton.propTypes = {
defaultSelected: PropTypes.string,
label: PropTypes.string,
format: PropTypes.string,
href: PropTypes.string,
download: PropTypes.string,
onClick: PropTypes.func,
context: PropTypes.shape({}),
};
export default ExplorerOutputButton;
| odota/web/src/components/Explorer/ExplorerOutputButton.jsx/0 | {
"file_path": "odota/web/src/components/Explorer/ExplorerOutputButton.jsx",
"repo_id": "odota",
"token_count": 355
} | 259 |
import React from 'react';
import { connect } from 'react-redux';
import PropTypes from 'prop-types';
import Clear from 'material-ui/svg-icons/content/clear';
import Filter from 'material-ui/svg-icons/content/filter-list';
import FlatButton from 'material-ui/FlatButton';
import styled from 'styled-components';
import constants from '../constants';
const StyledDiv = styled.div`
display: flex;
align-items: center;
text-transform: uppercase;
& svg {
width: 24px;
height: 24px;
margin: 0 5px;
transition: all 450ms cubic-bezier(0.23, 1, 0.32, 1) 0ms;
user-select: none;
}
`;
const getIcon = (show) => {
if (!show) {
return <Filter style={{ fill: constants.colorBlue }} />;
}
return <Clear style={{ fill: constants.colorDanger }} />;
};
const ShowFormToggle = ({ toggleShowForm, showForm, strings }) => (
<FlatButton onClick={() => toggleShowForm()}>
<StyledDiv>
{getIcon(showForm)}
<span>{showForm ? strings.filter_button_text_close : strings.filter_button_text_open}</span>
</StyledDiv>
</FlatButton>
);
ShowFormToggle.propTypes = {
toggleShowForm: PropTypes.func,
showForm: PropTypes.bool,
strings: PropTypes.shape({}),
};
const mapStateToProps = state => ({
strings: state.app.strings,
});
export default connect(mapStateToProps)(ShowFormToggle);
| odota/web/src/components/Form/ShowFormToggle.jsx/0 | {
"file_path": "odota/web/src/components/Form/ShowFormToggle.jsx",
"repo_id": "odota",
"token_count": 475
} | 260 |
import React from 'react';
import { shape, bool, node } from 'prop-types';
import styled from 'styled-components';
const Wrapper = styled.span`
background: rgba(0, 0, 0, .05);
display: flex;
flex-direction: row;
align-items: center;
padding: 8px;
&:nth-child(2n) {
background: rgba(0, 0, 0, .15);
}
`;
const Attribute = ({
style, primary, children,
}) => (
<Wrapper style={style} primary={primary}>
{children}
</Wrapper>
);
Attribute.propTypes = {
style: shape({}),
primary: bool,
children: node,
};
export default Attribute;
| odota/web/src/components/Hero/Attribute.jsx/0 | {
"file_path": "odota/web/src/components/Hero/Attribute.jsx",
"repo_id": "odota",
"token_count": 210
} | 261 |
import React from 'react';
import styled from 'styled-components';
import nanoid from 'nanoid';
import propTypes from 'prop-types';
import TalentsTooltip from '../TalentsTooltip';
import constants from '../constants';
const Wrapper = styled.div`
background: linear-gradient(to bottom, ${constants.colorBlueMuted}, ${constants.primarySurfaceColor});
border-radius: 4px;
box-shadow: 0 2px 2px rgba(0, 0, 0, .3);
position: relative;
`;
const Icon = styled.img`
border-radius: 4px;
display: block;
height: auto;
opacity: .7;
overflow: hidden;
transition: opacity .2s, box-shadow .4s, transform .2s;
width: 100%;
&:hover {
opacity: 1;
box-shadow: 0 0 150px rgba(255, 255, 255, .4);
transform: scale(1.1);
}
`;
const Talents = ({ talents }) => {
const ttId = nanoid();
return (
<Wrapper data-tip data-for={ttId}>
<Icon src="/assets/images/dota2/talent_tree.svg" alt="Talents" />
<TalentsTooltip talents={talents} ttId={ttId} />
</Wrapper>
);
};
Talents.propTypes = {
talents: propTypes.oneOfType([
propTypes.object,
propTypes.array,
]).isRequired,
};
export default Talents;
| odota/web/src/components/Hero/Talents.jsx/0 | {
"file_path": "odota/web/src/components/Hero/Talents.jsx",
"repo_id": "odota",
"token_count": 433
} | 262 |
import React from 'react';
export default props => (
<svg {...props} viewBox="0 0 300 300">
<path
d="M236.2,152.7L166.8,10.5c-6.8-14-26.9-14-33.7,0L76.4,126.7l0,0l-12.6,25.9c-1.6,3.5-3.1,7-4.4,10.6
c-1.1,3-2.1,6.1-3,9.2c-3.2,11.3-4.8,23.1-4.8,34.7c0,1.8,0,3.6,0.1,5.4c0,0.4,0.1,0.8,0.1,1.3c0.1,1.3,0.2,2.6,0.3,3.9
c0.1,0.7,0.2,1.3,0.2,1.9c0.1,1,0.2,2.1,0.4,3.1c0.1,0.7,0.3,1.4,0.4,2.2c0.2,0.9,0.3,1.9,0.5,2.8c0.2,0.8,0.3,1.5,0.5,2.3
c0.2,0.8,0.4,1.7,0.6,2.5c0.2,0.8,0.4,1.6,0.7,2.4c0.2,0.8,0.4,1.5,0.6,2.3c0.3,0.8,0.5,1.6,0.8,2.4c0.2,0.7,0.5,1.4,0.7,2.1
c0.3,0.8,0.7,1.7,1,2.5c0.3,0.6,0.5,1.2,0.8,1.9c0.4,0.9,0.8,1.7,1.2,2.5c0.3,0.5,0.5,1.1,0.8,1.6c0.4,0.9,0.9,1.7,1.4,2.6
c0.3,0.5,0.5,1,0.8,1.5c0.5,0.9,1,1.7,1.5,2.6c0.3,0.4,0.5,0.9,0.8,1.3c0.6,0.9,1.2,1.7,1.7,2.6c0.3,0.4,0.5,0.8,0.8,1.1
c0.6,0.9,1.3,1.7,2,2.6c0.3,0.3,0.5,0.7,0.7,1c0.7,0.9,1.4,1.7,2.2,2.6c0.2,0.3,0.5,0.6,0.7,0.8c0.8,0.9,1.6,1.7,2.4,2.5
c0.2,0.2,0.4,0.5,0.6,0.7c0.8,0.9,1.7,1.7,2.6,2.5c0.2,0.2,0.4,0.4,0.6,0.6c0.9,0.8,1.9,1.6,2.8,2.4c0.2,0.1,0.3,0.3,0.5,0.4
c1,0.8,2,1.6,3.1,2.4c0.1,0.1,0.3,0.2,0.4,0.3c1.1,0.8,2.2,1.6,3.3,2.3c0.1,0.1,0.2,0.2,0.4,0.3c1.1,0.8,2.3,1.5,3.5,2.2
c0.1,0.1,0.2,0.1,0.3,0.2c1.2,0.7,2.5,1.4,3.7,2.1c0.1,0,0.1,0.1,0.2,0.1c1.3,0.7,2.6,1.3,3.9,2c0,0,0.1,0,0.1,0.1
c1.4,0.6,2.7,1.2,4.1,1.8c0,0,0,0,0.1,0c12.7,5.3,27,8.2,42,8.3c0,0,0,0,0,0l0,0c0.5,0,1,0,1.4,0c54.3,0,98.3-34.8,98.3-92.8
C248.3,188.5,244.2,169.6,236.2,152.7z M121.5,160.3c-0.3,0.4-21.1,28.8-16.4,66.7c0.8,6.2-3.6,11.8-9.8,12.6
c-0.5,0.1-0.9,0.1-1.4,0.1c-5.6,0-10.5-4.2-11.2-9.9c-5.8-47.4,19.8-81.7,20.8-83.1c3.8-5,10.8-5.9,15.8-2.1
C124.2,148.3,125.2,155.4,121.5,160.3z"
/>
</svg>
);
| odota/web/src/components/Icons/BloodDrop.jsx/0 | {
"file_path": "odota/web/src/components/Icons/BloodDrop.jsx",
"repo_id": "odota",
"token_count": 1577
} | 263 |
import React from 'react';
export default props => (
<svg {...props} viewBox="0 0 96 96">
<g>
<path d="M66.3,50.3v-4.6c0-0.6-0.2-1.2-0.7-1.6c-0.5-0.5-1-0.7-1.6-0.7H52.6V32c0-0.6-0.2-1.2-0.7-1.6
c-0.5-0.5-1-0.7-1.6-0.7h-4.6c-0.6,0-1.2,0.2-1.6,0.7c-0.5,0.5-0.7,1-0.7,1.6v11.5H32c-0.6,0-1.2,0.2-1.6,0.7
c-0.5,0.5-0.7,1-0.7,1.6v4.6c0,0.6,0.2,1.2,0.7,1.6c0.5,0.5,1,0.7,1.6,0.7h11.5V64c0,0.6,0.2,1.2,0.7,1.6c0.5,0.5,1,0.7,1.6,0.7
h4.6c0.6,0,1.2-0.2,1.6-0.7c0.5-0.5,0.7-1,0.7-1.6V52.6H64c0.6,0,1.2-0.2,1.6-0.7C66.1,51.4,66.3,50.9,66.3,50.3z M75.5,30.8v34.4
c0,2.8-1,5.3-3,7.3c-2,2-4.4,3-7.3,3H30.8c-2.8,0-5.3-1-7.3-3c-2-2-3-4.4-3-7.3V30.8c0-2.8,1-5.3,3-7.3s4.4-3,7.3-3h34.4
c2.8,0,5.3,1,7.3,3C74.5,25.5,75.5,28,75.5,30.8z"
/>
</g>
</svg>
);
| odota/web/src/components/Icons/PlusSquare.jsx/0 | {
"file_path": "odota/web/src/components/Icons/PlusSquare.jsx",
"repo_id": "odota",
"token_count": 669
} | 264 |
export default [
// Radiant
{
id: 't4br',
style: { top: '82%', left: '12%' },
},
{
id: 't4tr',
style: { top: '79%', left: '8%' },
},
{
id: 't3br',
style: { top: '83.5%', left: '23%' },
},
{
id: 't2br',
style: { top: '85%', left: '46%' },
},
{
id: 't1br',
style: { top: '82%', left: '75%' },
},
{
id: 't3mr',
style: { top: '71.5%', left: '18.5%' },
},
{
id: 't2mr',
style: { top: '63%', left: '27.5%' },
},
{
id: 't1mr',
style: { top: '54%', left: '38%' },
},
{
id: 't3tr',
style: { top: '68%', left: '8%' },
},
{
id: 't2tr',
style: { top: '53%', left: '9%' },
},
{
id: 't1tr',
style: { top: '36%', left: '9.5%' },
},
// Barracks
{
id: 'brbr',
style: { top: '80.5%', left: '20%' },
},
{
id: 'bmbr',
style: { top: '84.5%', left: '20%' },
},
{
id: 'brmr',
style: { top: '72%', left: '15%' },
},
{
id: 'bmmr',
style: { top: '74.5%', left: '18%' },
},
{
id: 'brtr',
style: { top: '70.5%', left: '6.5%' },
},
{
id: 'bmtr',
style: { top: '70.5%', left: '10.5%' },
},
// Dire
{
id: 't4bd',
style: { top: '16%', left: '84%' },
},
{
id: 't4td',
style: { top: '13%', left: '81%' },
},
{
id: 't3bd',
style: { top: '28%', left: '85.5%' },
},
{
id: 't2bd',
style: { top: '45%', left: '85%' },
},
{
id: 't1bd',
style: { top: '60%', left: '84%' },
},
{
id: 't3md',
style: { top: '24%', left: '73%' },
},
{
id: 't2md',
style: { top: '33%', left: '64%' },
},
{
id: 't1md',
style: { top: '43.5%', left: '51%' },
},
{
id: 't3td',
style: { top: '12.5%', left: '70%' },
},
{
id: 't2td',
style: { top: '11%', left: '49%' },
},
{
id: 't1td',
style: { top: '12%', left: '18%' },
},
// Barracks
{
id: 'brbd',
style: { top: '24%', left: '84%' },
},
{
id: 'bmbd',
style: { top: '24%', left: '88%' },
},
{
id: 'brmd',
style: { top: '19.5%', left: '74.5%' },
},
{
id: 'bmmd',
style: { top: '22%', left: '77.5%' },
},
{
id: 'brtd',
style: { top: '10%', left: '74%' },
},
{
id: 'bmtd',
style: { top: '14%', left: '74%' },
},
// Ancients
{
id: 'ar',
style: { top: '83%', left: '5%' },
},
{
id: 'ad',
style: { top: '9%', left: '84%' },
}];
| odota/web/src/components/Match/BuildingMap/buildingData733.js/0 | {
"file_path": "odota/web/src/components/Match/BuildingMap/buildingData733.js",
"repo_id": "odota",
"token_count": 1382
} | 265 |
import React from 'react';
import { connect } from 'react-redux';
import PropTypes from 'prop-types';
import ReactTooltip from 'react-tooltip';
import heroes from 'dotaconstants/build/heroes.json';
import styled from 'styled-components';
import {
formatSeconds,
isRadiant,
jsonFn,
getTeamName,
} from '../../../utility';
import {
IconBloodDrop,
IconRoshan,
IconBattle,
} from '../../Icons';
import PlayerThumb from '../PlayerThumb';
import constants from '../../constants';
import config from '../../../config';
const Styled = styled.div`
.clickable {
&[data-tip="true"] {
cursor: pointer;
}
}
.iconBattle {
transition: ${constants.linearTransition};
}
.radiantWinner {
fill: ${constants.colorSuccess} !important;
}
.direWinner {
fill: ${constants.colorDanger} !important;
}
.timeline {
width: 100%;
margin: 30px 0 15px;
display: flex;
flex-direction: row;
align-items: center;
& time {
margin: 0 5px;
@media only screen and (max-width: 768px) {
font-size: ${constants.fontSizeMedium};
}
}
& > section {
display: flex;
flex-direction: column;
align-items: center;
& > mark {
background: none;
color: ${constants.colorMuted};
font-size: ${constants.fontSizeSmall};
}
}
}
.battle {
width: 100%;
margin: 0 5px;
@media only screen and (max-width: 768px) {
margin: 0;
}
}
.line {
width: 100%;
display: flex;
height: 4px;
& div,
& section {
height: inherit;
}
& section {
background-color: ${constants.colorMuted};
}
}
.events {
position: relative;
width: 100%;
& header {
margin-bottom: 3px;
font-weight: ${constants.fontWeightNormal};
}
& .subtitle {
margin-left: 4px;
font-size: ${constants.fontSizeSmall};
font-weight: ${constants.fontWeightLight};
color: ${constants.colorMutedLight};
}
& mark {
position: absolute;
background: none;
width: 0;
height: 0;
& time {
color: ${constants.colorMutedLight};
font-size: ${constants.fontSizeSmall};
text-align: center;
position: absolute;
width: 32px;
left: -16px;
margin: 0;
}
& svg {
fill: ${constants.colorMutedLight};
width: 18px;
position: absolute;
left: -9px;
@media only screen and (max-width: 768px) {
width: 16px;
left: -8px;
}
}
& div[data-id="tooltip"] {
/* Override react-tooltip */
margin-top: 0 !important;
padding: 2px 6px !important;
margin-left: 5px !important;
font-weight: ${constants.fontWeightLight} !important;
white-space: nowrap;
& img {
height: 24px;
margin-right: 4px;
}
& span {
margin: 0 4px;
& img {
height: 8px;
}
}
& section {
display: flex;
flex-direction: row;
align-items: center;
}
& span.goldDelta {
margin-left: auto;
}
& .goldChange {
display: inline;
}
}
}
& .radiant,
& .dire {
border-style: solid;
margin-left: -6px;
}
& .radiant {
border-width: 0 6px 5px;
border-color: transparent transparent ${constants.colorSuccess} transparent;
bottom: 4px;
& time {
top: 11px;
}
& svg {
bottom: 5px;
}
}
& .dire {
top: 0;
border-width: 5px 6px 0 6px;
border-color: ${constants.colorDanger} transparent transparent transparent;
& time {
top: -28px;
}
& svg {
top: 5px;
}
}
& .teamfight {
bottom: 0;
height: 4px;
& svg {
width: 12px;
top: -5px;
left: calc(50% - 5px);
filter: drop-shadow(1px 0 3px ${constants.darkPrimaryColor});
@media only screen and (max-width: 768px) {
width: 10px;
top: -3px;
left: calc(50% - 3px);
}
}
}
& .battleHorn {
width: 2px;
height: 4px;
bottom: 0;
background-color: ${constants.textColorPrimary};
}
}
.goldChange {
&::after {
content: '';
border-style: solid;
display: inline-block;
}
}
.goldGot {
&::after {
border-width: 0 4px 7px 4px;
border-color: transparent transparent ${constants.colorSuccess} transparent;
}
}
.goldLost {
&::after {
border-width: 7px 4px 0 4px;
border-color: ${constants.colorDanger} transparent transparent transparent;
}
}
.matchNumbers {
text-align: center;
margin: 0 5px;
& > div {
display: inline;
& span {
font-size: ${constants.fontSizeSmall};
color: ${constants.colorMutedLight};
white-space: pre-line;
&:first-child {
margin-left: 20px;
}
}
@media only screen and (max-width: 768px) {
font-size: ${constants.fontSizeMedium};
}
@media only screen and (max-width: 560px) {
display: block;
line-height: 2;
& span {
margin-left: 0;
}
}
}
}
.selectedTeamfight {
fill: ${constants.colorGolden} !important;
transform: scale(1.66, 1.66);
}
`;
const heroesArr = jsonFn(heroes);
const getWinnerStyle = obj =>
(obj && obj.radiant_gold_advantage_delta >= 0 ? 'radiantWinner' : 'direWinner');
const Timeline = ({
match,
onTeamfightClick,
onTeamfightHover,
selectedTeamfight,
strings,
}) => {
const preHorn = 90; // Seconds before the battle horn
if (match.objectives && match.objectives.length > 0) {
// Firstblood
const fbIndex = match.objectives.findIndex(obj => obj.type === 'CHAT_MESSAGE_FIRSTBLOOD');
let fbArr = [{ type: 'firstblood', time: match.first_blood_time || 0 }];
if (fbIndex > -1 && match.objectives[fbIndex].player_slot !== undefined) {
const killer = match.players.find(player =>
player.player_slot === match.objectives[fbIndex].player_slot) || {};
const killerLog = killer.kills_log;
fbArr = [{
type: 'firstblood',
time: match.objectives[fbIndex].time,
player_slot: match.objectives[fbIndex].player_slot,
key: killerLog && killerLog[0] ? killerLog[0].key : null,
}];
}
const events = fbArr
// Roshan kills, team 2 = radiant, 3 = dire
.concat(match.objectives
.filter(obj => obj.type === 'CHAT_MESSAGE_ROSHAN_KILL')
.map((obj, i) => ({
type: 'roshan',
time: obj.time,
team: obj.team,
key: i,
})) || [])
// Teamfights
.concat(match.teamfights && match.teamfights.length > 0 ?
match.teamfights.map(fight => ({
type: 'teamfight',
start: fight.start,
end: fight.end,
time: (fight.start + fight.end) / 2,
radiant_gold_advantage_delta: fight.radiant_gold_advantage_delta,
deaths: fight.players
.map((player, i) => ({
key: i,
gold_delta: player.gold_delta,
deaths: player.deaths,
}))
.filter(String),
})) : []);
// Aegis pickups
const aegis = (match.objectives || [])
.filter(obj => (
obj.type === 'CHAT_MESSAGE_AEGIS' ||
obj.type === 'CHAT_MESSAGE_AEGIS_STOLEN' ||
obj.type === 'CHAT_MESSAGE_DENIED_AEGIS'
))
.map(obj => ({
type: 'aegis',
act: (
(obj.type === 'CHAT_MESSAGE_AEGIS_STOLEN' && 'stolen') ||
(obj.type === 'CHAT_MESSAGE_DENIED_AEGIS' && 'denied')
),
time: obj.time,
player_slot: obj.player_slot,
}));
let fTower = match.objectives.findIndex(o => o.type === 'CHAT_MESSAGE_TOWER_KILL' || o.type === 'CHAT_MESSAGE_TOWER_DENY');
fTower = match.objectives[fTower] ? match.objectives[fTower].time : null;
let fRax = match.objectives.findIndex(o => o.type === 'CHAT_MESSAGE_BARRACKS_KILL');
fRax = match.objectives[fRax] || null;
return (
Math.abs(events.filter(obj => obj.type === 'firstblood')[0].time - match.first_blood_time) <= preHorn &&
// some old (source1) matches have wrong time in objectives, ex: 271008789.
// preHorn (90) is just small allowable mismatch. Since first_blood_time always >= 0, ex: 2792706825, fb before battle horn
<Styled>
<main className="timeline">
<section>
<mark>{getTeamName(match.radiant_team, true)}</mark>
<time>-1:30</time>
<mark>{getTeamName(match.dire_team, false)}</mark>
</section>
<div className="battle">
<div className="line">
<section style={{ width: '100%' }} />
</div>
<div className="events">
<mark
className="battleHorn"
style={{
left: `${(preHorn * 100) / (match.duration + preHorn)}%`,
}}
/>
{
events.map((obj, i) => {
const side = (
obj.player_slot && isRadiant(obj.player_slot))
|| (obj.team && obj.team === 2
) ? 'radiant' : 'dire';
const wTeamfight = obj.type === 'teamfight' && (100 * (obj.end - obj.start)) / (match.duration + preHorn);
return (
<mark
key={`${obj.type}_${obj.time}`}
className={obj.type === 'teamfight' ? 'teamfight' : side}
style={{
left: obj.time && `${
((100 * (obj.time + preHorn)) / (match.duration + preHorn)) - (wTeamfight / 2)
}%`,
width: `${wTeamfight}%`,
// backgroundColor: obj.type === 'teamfight' && (
// obj.radiant_gold_advantage_delta >= 0 ? styles.green : styles.red
// ),
}}
>
{obj.type === 'firstblood' &&
<IconBloodDrop
data-tip
data-for={`event_${i}`}
/>
}
{obj.type === 'roshan' &&
<IconRoshan
data-tip
data-for={`event_${i}`}
/>
}
{obj.type === 'teamfight' &&
<IconBattle
onClick={onTeamfightClick && onTeamfightClick(obj.start)}
onMouseEnter={onTeamfightHover && onTeamfightHover(obj.start)}
onMouseLeave={onTeamfightHover && onTeamfightHover(null)}
data-tip
data-for={`event_${i}`}
className={`iconBattle
${(selectedTeamfight === obj.start) ? 'selectedTeamfight' : getWinnerStyle(obj)}
${(selectedTeamfight || selectedTeamfight === 0) && 'clickable'}
`}
/>
}
<ReactTooltip
// Hide tooltip if it's not in objectives
id={obj.type === 'firstblood' && !obj.key && !obj.player_slot ? '' : `event_${i}`}
effect="solid"
place="right"
>
{obj.type === 'firstblood' &&
<section>
{match.players
.filter(player => player.player_slot === obj.player_slot)
.map(player => <PlayerThumb key={player.player_slot} {...player} />)
}
<span>
{obj.key ? strings.timeline_firstblood_key : strings.timeline_firstblood}
</span>
{obj.key &&
<PlayerThumb
{...match.players.find((player) => {
const foundHero = heroesArr('find')(hero => hero.name === obj.key);
return foundHero && player.hero_id === foundHero.id;
})}
/>
}
</section>
}
{obj.type === 'roshan' && aegis[obj.key] &&
match.players
.filter(player => player.player_slot === aegis[obj.key].player_slot)
.map(player => (
<section key={player.player_slot}>
<PlayerThumb {...player} />
<span>
{!aegis[obj.key].act && strings.timeline_aegis_picked_up}
{aegis[obj.key].act === 'stolen' && strings.timeline_aegis_snatched}
{aegis[obj.key].act === 'denied' && strings.timeline_aegis_denied}
</span>
<img
src="/assets/images/dota2/aegis_icon.png"
alt="Aegis of Immortality"
/>
</section>
))
}
{obj.type === 'teamfight' &&
<div>
<header>
{strings.timeline_teamfight_deaths}
<span className="subtitle">
& {strings.timeline_teamfight_gold_delta}, {formatSeconds(obj.start)} - {formatSeconds(obj.end)}
</span>
</header>
{obj.deaths.map(death => (
<section key={death.key}>
<PlayerThumb {...match.players[death.key]} />
{death.deaths > 0 ? <img src="/assets/images/player_death.png" alt="Death icon" /> : ''}
<span className="goldDelta">
{death.gold_delta > 0 ? <span className="goldChange goldGot" /> : <span className="goldChange goldLost" />}
{/* nothing if === 0 */}
<font style={{ color: constants.colorGolden }}>{Math.abs(death.gold_delta)} </font>
<img
alt="Gold"
src={`${config.VITE_IMAGE_CDN}/apps/dota2/images/tooltips/gold.png`}
/>
</span>
</section>
))}
</div>
}
</ReactTooltip>
<time>
{obj.type !== 'teamfight' && formatSeconds(obj.time)}
</time>
</mark>
);
})
}
</div>
</div>
<time>{formatSeconds(match.duration)}</time>
</main>
<div className="matchNumbers">
{fTower &&
<div>
<span>{strings.match_first_tower} </span>
{formatSeconds(fTower)}
</div>
}
{fRax &&
<div>
<span>{strings.match_first_barracks} ({strings[`barracks_value_${fRax.key}`]}) </span>
{formatSeconds(fRax.time)}
</div>
}
</div>
</Styled>
);
}
return null;
};
Timeline.propTypes = {
match: PropTypes.shape({}),
strings: PropTypes.shape({}),
};
const mapStateToProps = state => ({
strings: state.app.strings,
});
export default connect(mapStateToProps)(Timeline);
| odota/web/src/components/Match/Overview/Timeline.jsx/0 | {
"file_path": "odota/web/src/components/Match/Overview/Timeline.jsx",
"repo_id": "odota",
"token_count": 8806
} | 266 |
import React from 'react';
import PropTypes from 'prop-types';
import heroes from 'dotaconstants/build/heroes.json';
import Heading from '../Heading';
import Table from '../Table';
import TeamfightMap from '../Match/TeamfightMap';
import Purchases from '../Match/Purchases';
import Timeline from '../Match/Overview/Timeline';
import MatchGraph from '../Visualizations/Graph/MatchGraph';
import StackedBarGraph from '../Visualizations/Graph/StackedBarGraph';
import Draft from './Draft';
import Vision from './Vision';
import Laning from './Laning';
import CrossTable from './CrossTable';
import MatchLog from './MatchLog';
import MatchStory from './MatchStory';
import mcs from './matchColumns';
import Overview from './Overview';
import TeamTable from './TeamTable';
import Chat from './Chat';
import { StyledFlexContainer, StyledFlexElement } from './StyledMatch';
import { getHeroImageUrl, IMAGESIZE_ENUM } from '../../utility';
import config from '../../config';
const TickElement = (props) => {
const { x, y, payload } = props;
if (heroes[payload.value]) {
const href = getHeroImageUrl(payload.value, IMAGESIZE_ENUM.SMALL.suffix);
const imageProps = {
xlinkHref: href,
href,
width: IMAGESIZE_ENUM.SMALL.width,
height: IMAGESIZE_ENUM.SMALL.height,
x: (x - (IMAGESIZE_ENUM.SMALL.width / 2)),
y,
};
return <image {...imageProps} />;
}
return null;
};
TickElement.propTypes = {
x: PropTypes.number,
y: PropTypes.number,
payload: PropTypes.shape({}),
};
const matchPages = (strings) => {
const {
benchmarksColumns,
performanceColumns,
lastHitsTimesColumns,
unitKillsColumns,
actionsColumns,
runesColumns,
cosmeticsColumns,
// goldReasonsColumns,
// xpReasonsColumns,
objectiveDamageColumns,
analysisColumns,
inflictorsColumns,
castsColumns,
fantasyColumns,
} = mcs(strings);
const gosuUrl = 'https://gosu.ai/dota/?utm_source=opendota&utm_medium=cpc&utm_campaign=';
const gosuIcon = '/assets/images/gosu-24px.png';
return [Overview(strings, gosuUrl, gosuIcon), {
name: strings.tab_benchmarks,
key: 'benchmarks',
content: match => (
<div>
<TeamTable
players={match.players}
columns={benchmarksColumns(match)}
heading={strings.heading_benchmarks}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_benchmarks : null}
buttonTo={`${gosuUrl}Benchmarks`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
hoverRowColumn
/>
</div>),
}, {
name: strings.tab_drafts,
key: 'draft',
parsed: true,
hidden: match => match.game_mode !== 2,
content: match => (
<div>
<Draft
gameMode={match.game_mode}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
draft={match.draft_timings}
startTime={match.start_time}
sponsorIcon={gosuIcon}
sponsorURL={gosuUrl}
strings={strings}
/>
</div>),
}, {
name: strings.tab_performances,
key: 'performances',
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={performanceColumns}
heading={strings.heading_performances}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_performances : null}
buttonTo={`${gosuUrl}Performances`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
summable
hoverRowColumn
/>
</div>),
}, {
name: strings.tab_laning,
key: 'laning',
parsed: true,
content: match => (
<div>
<Laning match={match} sponsorURL={gosuUrl} sponsorIcon={gosuIcon} />
</div>),
}, {
name: strings.tab_combat,
key: 'combat',
skeleton: true,
parsed: true,
content: match => (
<div>
{config.VITE_ENABLE_GOSUAI &&
<Heading
buttonLabel={strings.gosu_combat}
buttonTo={`${gosuUrl}Combat`}
buttonIcon={gosuIcon}
/>
}
<StyledFlexContainer>
<StyledFlexElement>
<Heading title={strings.heading_kills} />
<CrossTable match={match} field1="killed" field2="killed_by" />
</StyledFlexElement>
<StyledFlexElement>
<Heading title={strings.heading_damage} />
<CrossTable match={match} field1="damage" field2="damage_taken" />
</StyledFlexElement>
</StyledFlexContainer>
<TeamTable
players={match.players}
columns={inflictorsColumns}
heading={strings.heading_damage}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
/>
</div>),
}, {
name: strings.tab_farm,
key: 'farm',
skeleton: true,
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={unitKillsColumns}
heading={strings.heading_unit_kills}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_farm : null}
buttonTo={`${gosuUrl}Farm`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
summable
hoverRowColumn
/>
<TeamTable
players={match.players}
columns={lastHitsTimesColumns(match)}
heading={strings.heading_last_hits}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
summable
hoverRowColumn
/>
<StackedBarGraph
columns={match.players.map(player => ({ ...player.gold_reasons, name: player.hero_id }))}
heading={strings.heading_gold_reasons}
type="gold_reasons"
tooltipFormatter={heroId => heroes[heroId] && heroes[heroId].localized_name}
tickElement={TickElement}
/>
<StackedBarGraph
columns={match.players.map(player => ({ ...player.xp_reasons, name: player.hero_id }))}
heading={strings.heading_xp_reasons}
type="xp_reasons"
tooltipFormatter={heroId => heroes[heroId] && heroes[heroId].localized_name}
tickElement={TickElement}
/>
{/*
<TeamTable
players={match.players}
columns={goldReasonsColumns}
heading={strings.heading_gold_reasons}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
/>
<TeamTable
players={match.players}
columns={xpReasonsColumns}
heading={strings.heading_xp_reasons}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
/>
*/}
</div>),
}, {
name: strings.tab_items,
key: 'purchases',
skeleton: true,
parsed: true,
content: match => (
<div>
<Purchases
match={match}
sponsorURL={gosuUrl}
sponsorIcon={gosuIcon}
/>
</div>),
}, {
name: strings.tab_graphs,
key: 'graphs',
skeleton: true,
parsed: true,
content: match => (
<div>
<Timeline match={match} />
<MatchGraph match={match} type="difference" sponsorURL={gosuUrl} sponsorIcon={gosuIcon} />
<MatchGraph match={match} type="gold" />
<MatchGraph match={match} type="xp" />
<MatchGraph match={match} type="lh" />
</div>),
}, {
name: strings.tab_casts,
key: 'casts',
skeleton: true,
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={castsColumns}
heading={strings.heading_casts}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_default : null}
buttonTo={`${gosuUrl}Casts`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
/>
</div>),
}, {
name: strings.tab_objectives,
key: 'objectives',
skeleton: true,
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={objectiveDamageColumns}
heading={strings.heading_objective_damage}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_default : null}
buttonTo={`${gosuUrl}Objectives`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
hoverRowColumn
/>
<TeamTable
players={match.players}
columns={runesColumns}
heading={strings.heading_runes}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
hoverRowColumn
/>
</div>),
}, {
name: strings.tab_vision,
key: 'vision',
skeleton: true,
parsed: true,
content: match => <Vision match={match} sponsorURL={gosuUrl} sponsorIcon={gosuIcon} hoverRowColumn />,
}, {
name: strings.tab_actions,
key: 'actions',
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={actionsColumns}
heading={strings.heading_actions}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_actions : null}
buttonTo={`${gosuUrl}Actions`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
hoverRowColumn
/>
</div>),
}, {
name: strings.tab_teamfights,
key: 'teamfights',
skeleton: true,
parsed: true,
content: match => (
<div>
<TeamfightMap teamfights={match.teamfights} match={match} sponsorURL={gosuUrl} sponsorIcon={gosuIcon} hoverRowColumn />
</div>),
}, {
name: strings.tab_analysis,
key: 'analysis',
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={analysisColumns}
heading={strings.heading_analysis}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_analysis : null}
buttonTo={`${gosuUrl}Analysis`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
/>
</div>),
}, {
name: strings.tab_cosmetics,
key: 'cosmetics',
parsed: true,
content: match => (
<div>
<Heading
title={strings.heading_cosmetics}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_default : null}
buttonTo={`${gosuUrl}Cosmetics`}
buttonIcon={gosuIcon}
/>
<Table data={match.players.filter(obj => obj.cosmetics.length > 0)} columns={cosmeticsColumns} />
</div>
),
}, {
name: strings.tab_log,
key: 'log',
skeleton: true,
parsed: true,
content: match => (
<div>
<MatchLog match={match} />
</div>),
}, {
name: strings.tab_fantasy,
key: 'fantasy',
parsed: true,
content: match => (
<div>
<TeamTable
players={match.players}
columns={fantasyColumns}
heading={strings.heading_fantasy}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_default : null}
buttonTo={`${gosuUrl}Fantasy`}
buttonIcon={gosuIcon}
radiantTeam={match.radiant_team}
direTeam={match.dire_team}
radiantWin={match.radiant_win}
hoverRowColumn
/>
</div>),
}, {
name: strings.tab_chat,
key: 'chat',
parsed: true,
content: (match) => {
const data = (match.chat || []).map((msg) => {
const p = match.players[msg.slot];
if (p) {
return {
...msg,
accountID: p.account_id,
heroID: p.hero_id,
name: p.name || p.personaname || strings.general_anonymous,
};
}
return msg;
});
return (
<div>
<Chat data={data} />
</div>
);
},
}, {
name: strings.tab_story,
key: 'story',
parsed: true,
content: match => (
<div>
<MatchStory match={match} />
</div>),
}];
};
export default (matchId, match, strings) => matchPages(strings).map(page => ({
// ...page,
name: page.name,
key: page.key,
parsed: page.parsed,
content: page.content,
route: `/matches/${matchId}/${page.key.toLowerCase()}`,
disabled: match && !match.version && page.parsed,
hidden: m => page.hidden && page.hidden(m),
skeleton: page.skeleton,
}));
| odota/web/src/components/Match/matchPages.jsx/0 | {
"file_path": "odota/web/src/components/Match/matchPages.jsx",
"repo_id": "odota",
"token_count": 6100
} | 267 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import ActivityCalendar from './ActivityCalendar';
import { getPlayerMatches } from '../../../../actions';
import Container from '../../../Container';
const defaultOptions = {
limit: null,
};
const Activity = ({
error, loading, strings, data,
}) => (
<Container title={strings.tab_activity} subtitle={strings.activity_subtitle} error={error} loading={loading}>
<ActivityCalendar strings={strings} data={data} />
</Container>
);
Activity.propTypes = {
error: PropTypes.string,
loading: PropTypes.bool,
strings: PropTypes.shape({}),
data: PropTypes.arrayOf(PropTypes.shape({})),
};
const getData = (props) => {
props.getPlayerMatches(props.playerId, props.location.search);
};
class RequestLayer extends React.Component {
static propTypes = {
playerId: PropTypes.string,
location: PropTypes.shape({
key: PropTypes.string,
}),
strings: PropTypes.shape({}),
};
componentDidMount() {
getData(this.props);
}
componentDidUpdate(prevProps) {
if (
this.props.playerId !== prevProps.playerId ||
this.props.location.key !== prevProps.location.key
) {
getData(this.props);
}
}
render() {
return <Activity {...this.props} />;
}
}
const mapStateToProps = state => ({
data: state.app.playerMatches.data,
loading: state.app.playerMatches.loading,
error: state.app.playerMatches.error,
strings: state.app.strings,
});
const mapDispatchToProps = dispatch => ({
getPlayerMatches: (playerId, options = defaultOptions) =>
dispatch(getPlayerMatches(playerId, options)),
});
export default connect(
mapStateToProps,
mapDispatchToProps,
)(RequestLayer);
| odota/web/src/components/Player/Pages/Activity/Activity.jsx/0 | {
"file_path": "odota/web/src/components/Player/Pages/Activity/Activity.jsx",
"repo_id": "odota",
"token_count": 600
} | 268 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import { getPlayerPeers } from '../../../../actions';
import Table from '../../../Table';
import Container from '../../../Container';
import { playerPeersColumns } from './playerPeersColumns';
const Peers = ({
data, playerId, error, loading, strings,
}) => (
<Container title={strings.heading_peers} error={error} loading={loading}>
<Table paginated columns={playerPeersColumns(playerId, strings)} data={data} placeholderMessage={strings.peers_none} />
</Container>
);
Peers.propTypes = {
data: PropTypes.arrayOf({}),
error: PropTypes.string,
playerId: PropTypes.string,
loading: PropTypes.bool,
strings: PropTypes.shape({}),
};
const getData = (props) => {
props.getPlayerPeers(props.playerId, props.location.search);
};
class RequestLayer extends React.Component {
static propTypes = {
location: PropTypes.shape({
key: PropTypes.string,
}),
playerId: PropTypes.string,
strings: PropTypes.shape({}),
}
componentDidMount() {
getData(this.props);
}
componentDidUpdate(prevProps) {
if (this.props.playerId !== prevProps.playerId || this.props.location.key !== prevProps.location.key) {
getData(this.props);
}
}
render() {
return <Peers {...this.props} />;
}
}
const mapStateToProps = state => ({
data: state.app.playerPeers.data,
error: state.app.playerPeers.error,
loading: state.app.playerPeers.loading,
strings: state.app.strings,
});
const mapDispatchToProps = dispatch => ({
getPlayerPeers: (playerId, options) => dispatch(getPlayerPeers(playerId, options)),
});
export default connect(mapStateToProps, mapDispatchToProps)(RequestLayer);
| odota/web/src/components/Player/Pages/Peers/Peers.jsx/0 | {
"file_path": "odota/web/src/components/Player/Pages/Peers/Peers.jsx",
"repo_id": "odota",
"token_count": 593
} | 269 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import styled from 'styled-components';
import Button from '@material-ui/core/Button';
import LockIcon from '@material-ui/icons/Lock';
import config from '../../../config';
const Styled = styled.div`
text-align: center;
padding-top: 5%;
.playerProfilePrivateTitle {
font-size: 2rem;
margin-bottom: 1%;
display: flex;
justify-content: center;
align-items: center;
}
.lockIcon {
font-size: 1.8rem;
margin-right: 2%;
}
.playerProfilePrivateDescription {
margin-bottom: 2%;
}
.signInWithSteamButton {
border: solid 1px #FFFFFF;
color: #FFFFFF;
padding: 1% 2%;
}
`
const PlayerProfilePrivate = ({ strings }) => {
const handleButtonClick = () => {
window.location.href = `${config.VITE_API_HOST}/login`;
};
const playerProfilePrivateTitle = (strings.player_profile_private_title || "").toUpperCase();
return (
<Styled>
<div>
<div className="playerProfilePrivateTitle">
<LockIcon className="lockIcon" />
<div>{playerProfilePrivateTitle}</div>
</div>
<div className="playerProfilePrivateDescription">{strings.player_profile_private_description}</div>
<Button
className="signInWithSteamButton"
onClick={handleButtonClick}
>
{strings.sign_in_with_steam}
</Button>
</div>
</Styled>
);
}
PlayerProfilePrivate.propTypes = {
strings: PropTypes.shape({}),
}
const mapStateToProps = state => ({
strings: state.app.strings,
})
export default connect(mapStateToProps)(PlayerProfilePrivate); | odota/web/src/components/Player/PlayerProfilePrivate/index.jsx/0 | {
"file_path": "odota/web/src/components/Player/PlayerProfilePrivate/index.jsx",
"repo_id": "odota",
"token_count": 609
} | 270 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import Helmet from 'react-helmet';
import fuzzy from 'fuzzy';
import { withRouter } from 'react-router-dom';
import { getSearchResultAndPros } from '../../actions';
import SearchResult from './SearchResult';
const extract = item => `${item.name}${item.team_name}`;
const Search = ({
data, pros, query, matchData, strings, ...rest
}) => (
<div>
<Helmet title={`${query} - ${strings.title_search}`} />
<SearchResult {...rest} players={data || []} pros={pros || []} matchData={matchData} />
</div>
);
Search.propTypes = {
data: PropTypes.shape({}),
pros: PropTypes.arrayOf({}),
query: PropTypes.string,
match: PropTypes.shape({}),
matchData: PropTypes.arrayOf({}),
strings: PropTypes.shape({}),
};
const mapStateToProps = (state) => {
const {
error, loading, done, data, query,
} = state.app.search;
return {
playersLoading: loading,
playersError: error,
done,
data,
query,
pros: fuzzy.filter(query, state.app.proPlayers.data, { extract }).map(item => ({ ...item.original })),
prosLoading: state.app.proPlayers.loading,
prosError: state.app.proPlayers.error,
matchData: state.app.match.data,
matchLoading: state.app.match.loading,
matchError: state.app.match.error,
strings: state.app.strings,
};
};
const mapDispatchToProps = dispatch => ({
dispatchSearch: query => dispatch(getSearchResultAndPros(query)),
});
export default withRouter(connect(mapStateToProps, mapDispatchToProps)(Search));
| odota/web/src/components/Search/Search.jsx/0 | {
"file_path": "odota/web/src/components/Search/Search.jsx",
"repo_id": "odota",
"token_count": 547
} | 271 |
import Spinner from './Spinner';
export default Spinner;
| odota/web/src/components/Spinner/index.js/0 | {
"file_path": "odota/web/src/components/Spinner/index.js",
"repo_id": "odota",
"token_count": 17
} | 272 |
import React from 'react';
import NavigationArrowUpward from 'material-ui/svg-icons/navigation/arrow-upward';
import NavigationArrowDownward from 'material-ui/svg-icons/navigation/arrow-downward';
const getTotalWidth = columns => columns.reduce((prev, current) => prev + current.width, 0);
const getWidthStyle = (column, total) => (column / total);
const isSortField = (sortField, field) => sortField === field;
const getSortIcon = (sortState, sortField, field, style) => {
if (isSortField(sortField, field)) {
if (sortState === 'asc') {
return <NavigationArrowUpward style={style} />;
}
if (sortState === 'desc') {
return <NavigationArrowDownward style={style} />;
}
}
return null;
};
export {
getTotalWidth,
getWidthStyle,
isSortField,
getSortIcon,
};
| odota/web/src/components/Table/tableHelpers.jsx/0 | {
"file_path": "odota/web/src/components/Table/tableHelpers.jsx",
"repo_id": "odota",
"token_count": 273
} | 273 |
import React from 'react';
import PropTypes from 'prop-types';
import { connect } from 'react-redux';
import {
ReferenceArea,
XAxis,
YAxis,
Tooltip,
Line,
LineChart,
CartesianGrid,
ReferenceLine,
Legend,
ResponsiveContainer,
} from 'recharts';
import heroes from 'dotaconstants/build/heroes.json';
import playerColors from 'dotaconstants/build/player_colors.json';
import Heading from '../../Heading';
import constants from '../../constants';
import { StyledTooltip, StyledTooltipTeam, StyledRadiant, StyledDire, StyledHolder, GoldSpan, XpSpan, StyledTooltipGold, StyledCustomizedTooltip } from './Styled';
import config from '../../../config';
const formatGraphTime = minutes => `${minutes}:00`;
const generateDiffData = (match) => {
const radiantGoldAdv = match.radiant_gold_adv;
const radiantXpAdv = match.radiant_xp_adv;
const data = [];
if (radiantGoldAdv && radiantXpAdv) {
radiantXpAdv.forEach((rXpAdv, index) => {
if (index <= Math.floor(match.duration / 60)) {
data.push({ time: index, rXpAdv, rGoldAdv: radiantGoldAdv[index] });
}
});
}
return data;
};
const CustomizedTooltip = ({ label, payload }) => (
<StyledCustomizedTooltip>
<div className="label">{label}</div>
{payload.map((data, i) => (
<div value={data.value} className={`data ${i < 5 && 'isRadiant'}`} style={{ borderLeft: `8px solid ${data.color}` }}>
{data.dataKey}: {data.value}
</div>)).sort((a, b) => b.props.value - a.props.value)
}
</StyledCustomizedTooltip>
);
CustomizedTooltip.propTypes = {
payload: PropTypes.shape({}),
label: PropTypes.number,
};
const XpTooltipContent = ({ payload, strings }) => {
try {
const data = payload && payload[0] && payload[0].payload;
const { rXpAdv, rGoldAdv, time } = data;
return (
<StyledTooltip>
<StyledTooltipGold>
<span>{`${formatGraphTime(time)}`}</span>
</StyledTooltipGold>
<br />
<StyledTooltipGold>
<StyledTooltipTeam
color={rGoldAdv > 0 ? constants.colorSuccess : constants.colorDanger}
>
{rGoldAdv > 0 ? strings.general_radiant : strings.general_dire}
</StyledTooltipTeam>
<GoldSpan>{Math.abs(rGoldAdv)} {strings.heading_graph_gold}</GoldSpan>
</StyledTooltipGold>
<br />
<StyledTooltipGold>
<StyledTooltipTeam
color={rXpAdv > 0 ? constants.colorSuccess : constants.colorDanger}
>
{rXpAdv > 0 ? strings.general_radiant : strings.general_dire}
</StyledTooltipTeam>
<XpSpan>{Math.abs(rXpAdv)} {strings.heading_graph_xp}</XpSpan>
</StyledTooltipGold>
</StyledTooltip>
);
} catch (e) {
return null;
}
};
XpTooltipContent.propTypes = {
payload: PropTypes.shape({}),
strings: PropTypes.shape({}),
};
const XpNetworthGraph = ({
match, strings, sponsorURL, sponsorIcon,
}) => {
if (!match.radiant_gold_adv || !match.radiant_xp_adv) {
return null;
}
const matchData = generateDiffData(match);
const maxY =
Math.ceil(Math.max(...match.radiant_gold_adv, ...match.radiant_xp_adv) / 5000) * 5000;
const minY =
Math.floor(Math.min(...match.radiant_gold_adv, ...match.radiant_xp_adv) / 5000) * 5000;
return (
<StyledHolder>
<StyledRadiant>{strings.general_radiant}</StyledRadiant>
<StyledDire>{strings.general_dire}</StyledDire>
<Heading
title={strings.heading_graph_difference}
buttonLabel={config.VITE_ENABLE_GOSUAI ? strings.gosu_default : null}
buttonTo={`${sponsorURL}Graphs`}
buttonIcon={sponsorIcon}
/>
<ResponsiveContainer width="100%" height={400}>
<LineChart
data={matchData}
margin={{
top: 5, right: 10, left: 10, bottom: 5,
}}
>
<ReferenceArea y1={0} y2={maxY} fill="rgba(102, 187, 106, 0.12)" />
<ReferenceArea y1={0} y2={minY} fill="rgba(255, 76, 76, 0.12)" />
<XAxis dataKey="time" tickFormatter={formatGraphTime} />
<YAxis domain={[minY, maxY]} mirror="true" padding={{ top: 5, bottom: 5 }} />
<ReferenceLine y={0} stroke="#505050" strokeWidth={2} opacity={1} />
<CartesianGrid
stroke="#505050"
strokeWidth={1}
opacity={0.5}
/>
<Tooltip content={<XpTooltipContent strings={strings} />} />
<Line
dot={false}
dataKey="rXpAdv"
stroke="#acc9ed"
strokeWidth={2}
name={strings.heading_graph_xp}
/>
<Line
dot={false}
dataKey="rGoldAdv"
stroke="#ffd455"
strokeWidth={2}
name={strings.heading_graph_gold}
/>
<Legend />
</LineChart>
</ResponsiveContainer>
</StyledHolder>
);
};
XpNetworthGraph.propTypes = {
match: PropTypes.shape({}),
strings: PropTypes.shape({}),
sponsorIcon: PropTypes.string,
sponsorURL: PropTypes.string,
};
class PlayersGraph extends React.Component {
static propTypes = {
match: PropTypes.shape({}),
type: PropTypes.string,
strings: PropTypes.shape({}),
}
constructor(props) {
super(props);
this.state = {
hoverHero: null,
};
}
handleMouseEnter = (o) => {
this.setState({
hoverHero: o.dataKey,
});
};
handleMouseLeave = () => {
this.setState({
hoverHero: null,
});
};
render() {
const { match, type, strings } = this.props;
const { hoverHero } = this.state;
const matchData = [];
if (match.players && match.players[0] && match.players[0][`${type}_t`]) {
match.players[0][`${type}_t`].forEach((value, index) => {
if (index <= Math.floor(match.duration / 60)) {
const obj = { time: formatGraphTime(index) };
match.players.forEach((player) => {
const hero = heroes[player.hero_id] || {};
obj[hero.localized_name] = player[`${type}_t`][index];
});
matchData.push(obj);
}
});
return (
<StyledHolder>
<Heading title={strings[`heading_graph_${type}`]} />
<ResponsiveContainer width="100%" height={400}>
<LineChart
data={matchData}
margin={{
top: 5, right: 10, left: 10, bottom: 5,
}}
>
<XAxis dataKey="time" />
<YAxis mirror="true" />
<CartesianGrid
stroke="#505050"
strokeWidth={1}
opacity={0.5}
/>
<Tooltip content={<CustomizedTooltip />} />
{match.players.map((player) => {
const hero = heroes[player.hero_id] || {};
const playerColor = playerColors[player.player_slot];
const isSelected = heroes[player.hero_id] && (hoverHero === heroes[player.hero_id].localized_name);
const opacity = (!hoverHero || isSelected) ? 1 : 0.25;
const stroke = (isSelected) ? 4 : 2;
return (<Line
dot={false}
dataKey={hero.localized_name}
stroke={playerColor}
strokeWidth={stroke}
strokeOpacity={opacity}
name={hero.localized_name}
/>);
})}
<Legend onMouseEnter={this.handleMouseEnter} onMouseLeave={this.handleMouseLeave} />
</LineChart>
</ResponsiveContainer>
</StyledHolder>
);
}
return null;
}
}
const MatchGraph = ({
type, match, width, strings, sponsorURL, sponsorIcon,
}) => {
if (type === 'difference') {
return <XpNetworthGraph match={match} width={width} strings={strings} sponsorURL={sponsorURL} sponsorIcon={sponsorIcon} />;
} else if (type === 'gold' || type === 'xp' || type === 'lh') {
return <PlayersGraph type={type} match={match} width={width} strings={strings} />;
}
return null;
};
MatchGraph.defaultProps = {
width: 1200,
};
MatchGraph.propTypes = {
width: PropTypes.number,
match: PropTypes.shape({}),
type: PropTypes.string,
strings: PropTypes.shape({}),
sponsorIcon: PropTypes.string,
sponsorURL: PropTypes.string,
};
const mapStateToProps = state => ({
strings: state.app.strings,
});
export default connect(mapStateToProps)(MatchGraph);
| odota/web/src/components/Visualizations/Graph/MatchGraph.jsx/0 | {
"file_path": "odota/web/src/components/Visualizations/Graph/MatchGraph.jsx",
"repo_id": "odota",
"token_count": 3841
} | 274 |
export default {
defaultPrimaryColor: 'rgba(0, 0, 0, 0.4)',
defaultPrimaryColorSolid: 'rgba(0, 0, 0, 0.37)',
darkPrimaryColor: 'rgba(0, 0, 0, 0.6)',
almostBlack: 'rgba(0, 0, 0, 0.9)',
colorSuccess: '#66BB6A',
colorDanger: '#ff4c4c',
colorGreen: '#66BB6A',
colorRed: '#ff4c4c',
colorBlue: '#6BF',
colorMuted: '#727272',
colorYelor: '#FFAB40',
colorGolden: 'rgb(201, 175, 29)',
colorBlueGray: '#7c99a8',
green: '#66BB6A',
blue: '#6BF',
golden: 'rgb(201, 175, 29)',
yelor: '#FFAB40',
red: '#ff4c4c',
lightGray: 'rgba(255, 255, 255, 0.6)',
colorBlackMuted: 'rgba(0, 0, 0, .75)',
colorBlueMuted: 'rgba(102, 187, 255, 0.3)',
colorYelorMuted: 'rgba(255, 171, 64, 0.3)',
colorMutedLight: 'rgba(255, 255, 255, 0.6)',
colorMutedGreen: '#325233',
colorMutedRed: '#523332',
colorRanked: 'rgba(241, 170, 64, 0.81)',
primaryLinkColor: '#6BF',
textColorPrimary: 'rgba(255, 255, 255, 0.87)',
primaryTextColor: 'rgba(255, 255, 255, 0.87)',
textColorSecondary: 'rgba(255, 255, 255, 0.6)',
secondaryTextColor: 'rgba(255, 255, 255, 0.6)',
primarySurfaceColor: 'rgb(22, 40, 62)',
secondarySurfaceColor: 'rgb(39, 39, 58)',
tableHeaderSurfaceColor: 'rgba(0, 0, 0, .3)',
tableRowOddSurfaceColor: 'rgba(255, 255, 255, .019)',
tableRowEvenSurfaceColor: 'rgba(0, 0, 0, .019)',
colorImmortal: 'rgba(17,17,35,0.65)',
colorImmortalAlt: 'rgba(17,17,35,0.45)',
colorDivine: 'rgba(33, 41, 69, 0.45)',
colorDivineAlt: 'rgba(33, 41, 69, 0.65)',
colorAncient: 'rgba(82, 52, 91, 0.45)',
colorAncientAlt: 'rgba(82, 52, 91, 0.65)',
colorLegend: 'rgba(84, 60, 26, 0.45)',
colorLegendAlt: 'rgba(84, 60, 26, 0.65)',
colorArchon: 'rgba(24, 85, 74, 0.45)',
colorArchonAlt: 'rgba(24, 85, 74, 0.65)',
colorCrusader: 'rgba(58, 73, 124, 0.45)',
colorCrusaderAlt: 'rgba(58, 73, 124, 0.65)',
colorGuardian: 'rgba(114, 79, 49, 0.45)',
colorGuardianAlt: 'rgba(114, 79, 49, 0.65)',
colorHerald: 'rgba(32, 74, 33, 0.45)',
colorHeraldAlt: 'rgba(32, 74, 33, 0.65)',
colorAttributeStr: '#f44336',
colorAttributeAgi: '#39d402',
colorAttributeInt: '#01a9f4',
colorDamageTypePure: '#d8ae53',
colorDamageTypeMagical: '#5b93d1',
colorDamageTypePhysical: '#ae2f28',
colorNeutralTier2: '#92E47E',
colorNeutralTier3: '#7F93FC',
colorNeutralTier4: '#D57BFF',
colorNeutralTier5: '#FFE195',
colorMana: '#578dca',
colorBoxBlue: 'rgba(71, 114, 179, 0.05)',
sliderTicksColor: '#757575',
sliderTicksColorActive: '#337AB7',
dividerColor: 'rgb(52, 50, 50)',
fontFamily: `
-apple-system, BlinkMacSystemFont,
"Segoe UI",
Roboto, "Droid Sans",
Ubuntu, Cantarell,
"Fira Sans",
Helvetica, Arial, sans-serif`,
tableFontFamily: `
-apple-system, BlinkMacSystemFont,
Tahoma, "Segoe UI",
Roboto, "Droid Sans",
Ubuntu, Cantarell,
"Fira Sans",
Helvetica, Arial, sans-serif`,
fontWeightLight: '300',
fontWeightNormal: '400',
fontWeightMedium: '500',
fontSizeCommon: '16px',
fontSizeMedium: '14px',
fontSizeSmall: '12px',
fontSizeTiny: '10px',
navDrawerWidth: '256px',
normalTransition: 'all 450ms cubic-bezier(0.23, 1, 0.32, 1) 0ms',
linearTransition: 'all 300ms linear',
wrapTablet: '1024px',
wrapMobile: '680px',
appWidth: 1200,
dotaMaxLevel: 30,
};
| odota/web/src/components/constants.js/0 | {
"file_path": "odota/web/src/components/constants.js",
"repo_id": "odota",
"token_count": 1514
} | 275 |
{
"yes": "Igen",
"no": "Nem",
"abbr_thousand": "k",
"abbr_million": "M",
"abbr_billion": "B",
"abbr_trillion": "T",
"abbr_quadrillion": "Q",
"abbr_not_available": "N/A",
"abbr_pick": "V",
"abbr_win": "NY",
"abbr_number": "No.",
"analysis_eff": "Vonal hatékonyság",
"analysis_farm_drought": "Legalacsonyabb APP 5 perces bontásban",
"analysis_skillshot": "Célbaért Skillshotok",
"analysis_late_courier": "Futár fejlesztés késedelem",
"analysis_wards": "Elhelyezett wardok",
"analysis_roshan": "Roshan megölve",
"analysis_rune_control": "Runák megszerezve",
"analysis_unused_item": "Nem használt aktív tárgy",
"analysis_expected": "of",
"announce_dismiss": "Elutasítás",
"announce_github_more": "Nézd meg GitHub-on",
"api_meta_description": "Az OpenDota API hozzáférést nyújt az OpenDota platform összetett Dota 2 statisztikáihoz. Hozzáférés teljesítmény grafikonokhoz, térképekhez, és sok minden máshoz. Kezdj bele ingyenesen.",
"api_title": "OpenDota API",
"api_subtitle": "Vigyél összetett statisztikát az alkalmazásodba és nyújts mélyreható betekintést a felhasználóknak.",
"api_details_free_tier": "Ingyenes Szint",
"api_details_premium_tier": "Prémium Szint",
"api_details_price": "Ár",
"api_details_price_free": "Ingyenes",
"api_details_price_prem": "$price minden $unit hívás után",
"api_details_key_required": "Kapsz API Kulcsot",
"api_details_key_required_free": "Nem",
"api_details_key_required_prem": "Igen -- fizetési módot kell megadni",
"api_details_call_limit": "Hívás Limit",
"api_details_call_limit_free": "$limit havonta",
"api_details_call_limit_prem": "Nincs",
"api_details_rate_limit": "Arányos Limit",
"api_details_rate_limit_val": "$num percenkénti hívás",
"api_details_support": "Támogatás",
"api_details_support_free": "Közösségi támogatás Discord csoportban",
"api_details_support_prem": "Elsőbbségi támogatás fő fejlesztőktől",
"api_get_key": "Kérem a kulcsom",
"api_docs": "Olvasd el a dokumentációt",
"api_header_details": "Részletek",
"api_charging": "$cost költség hívásonként.",
"api_credit_required": "Az API kulcshoz való hozzáféréshez meg kell adnod egy fizetési módot. Minden hónap elején automatikusan terheljük a kártyát a meglévő tartozásokkal.",
"api_failure": "HTTP 500 hibák nem számítanak bele a használatba, hiszen ez azt jelenti mi szúrtunk el valamit!",
"api_error": "Hiba a kérés feldolgozása közben. Próbáld újra. Ha nem tapasztalsz változást, keress minket support@opendota.com.",
"api_login": "Az API kulcs hozzáféréshez jelentkezz be",
"api_update_billing": "Számlázási mód megváltoztatása",
"api_delete": "Kulcs törlése",
"api_key_usage": "Hogy a kulcsodat használd, add hozzá a $param paramétert az API kérésedhez:",
"api_billing_cycle": "A jelenlegi számlázási ciklus vége $date.",
"api_billed_to": "Automatikusan számlázunk a $brand felé eddig: $last4",
"api_support": "Segítségre van szükséged? Email $email.",
"api_header_usage": "Használatod",
"api_usage_calls": "# API hívások",
"api_usage_fees": "Számított költség",
"api_month": "Hónap",
"api_header_key": "Kulcsod",
"api_header_table": "Kezdj bele ingyen. Folytasd elképesztően alacsony áron.",
"app_name": "OpenDota",
"app_language": "Nyelv",
"app_localization": "Localization",
"app_description": "Nyílt forráskódú Dota 2 adat platform",
"app_about": "Rólunk",
"app_privacy_terms": "Felhasználási Feltételek",
"app_api_docs": "API Dokumentáció",
"app_blog": "Blog",
"app_translate": "Fordítás",
"app_donate": "Adományozás",
"app_gravitech": "A Gravitech LLC Oldala",
"app_powered_by": "powered by",
"app_donation_goal": "Havi Adományozási Cél",
"app_sponsorship": "A támogatásoddal segíted, hogy a szolgáltatás ingyen elérhető legyen bárkinek.",
"app_twitter": "Kövess a Twitter-en",
"app_github": "Forráskó GitHub-on",
"app_discord": "Csevegj Discord-on",
"app_netlify": "A Netlify által telepítve",
"app_openunderlords": "OpenUnderlords - Dota Underlords statisztikák",
"app_steam_profile": "Steam Profil",
"app_confirmed_as": "Jóváhagyva mint",
"app_untracked": "Ez a felhasználó nem jelentkezett be az elmúlt időszakban, ezért az új meccsek felvételei nem lesznek automatikusan elemezve.",
"app_tracked": "Ez a felhasználó nem jelentkezett be az elmúlt időszakban, ezért az új meccsek felvételei automatikusan elemezve lesznek.",
"app_cheese_bought": "Sajt megvéve",
"app_contributor": "Ez a felhasználó hozzájárult az OpenDota projekt fejlesztéséhez",
"app_dotacoach": "Kérdezz meg egy Edzőt",
"app_pvgna": "Keress útmutatót",
"app_pvgna_alt": "Keress egy Dota 2 Útmutatót Pvgna-hoz",
"app_rivalry": "Fogadj Profi Mérkőzésekre",
"app_rivalry_team": "Fogadj {0} Mérkőzésekre",
"app_refresh": "Mérkőzés Történet Frissítése: Állíts sorba egy keresést adatvédelmi okok miatt hiányzó mérkőzésekre",
"app_refresh_label": "Frissítés",
"app_login": "Bejelentkezés",
"app_logout": "Kijelentkezés",
"app_results": "Eredmény(ek)",
"app_report_bug": "Hiba jelentése",
"app_pro_players": "Profi Játékosok",
"app_public_players": "Amatőr Játékosok",
"app_my_profile": "Profilom",
"barracks_value_1": "Dire Alső Közelhari",
"barracks_value_2": "Dire Alsó Távolsági",
"barracks_value_4": "Dire Középső Közelharci",
"barracks_value_8": "Dire Középső Távolsági",
"barracks_value_16": "Dire Felső Közelharci",
"barracks_value_32": "Dire Felső Távolsági",
"barracks_value_64": "Radiant Alsó Közelharci",
"barracks_value_128": "Radiant Alsó Távolsági",
"barracks_value_256": "Radiant Középső Közelharci",
"barracks_value_512": "Radiant Középső Távolsági",
"barracks_value_1024": "Radiant Felső Közelharci",
"barracks_value_2048": "Radiant Felső Távolsági",
"benchmarks_description": "{0} {1} egyenlő vagy nagyobb {2}% mint a jelenlegi teljesítménye a hősnek",
"fantasy_description": "{0} - {1} pontok",
"building_melee_rax": "Közelharci Barakk",
"building_range_rax": "Távolsági Barakk",
"building_lasthit": "utolsó találatot szerzett",
"building_damage": "sebzést szenvedett",
"building_hint": "A térképen lévő ikonok elemleírást tartalmaznak",
"building_denied": "beáldozott",
"building_ancient": "Ős",
"CHAT_MESSAGE_TOWER_KILL": "Toronyr",
"CHAT_MESSAGE_BARRACKS_KILL": "Barakkok",
"CHAT_MESSAGE_ROSHAN_KILL": "Roshan",
"CHAT_MESSAGE_AEGIS": "Felvette az Aegis-t",
"CHAT_MESSAGE_FIRSTBLOOD": "Első Vérontás",
"CHAT_MESSAGE_TOWER_DENY": "Torony Beáldozás",
"CHAT_MESSAGE_AEGIS_STOLEN": "Ellopta az Aegis-t",
"CHAT_MESSAGE_DENIED_AEGIS": "Beáldozta az Aegis-t",
"cumulative_cs": "Átlagolt Creep Pontok",
"cs_over_time": "Idő alatti Creep Pontok",
"cs_this_minute": "Creep Pontok ebben a percben",
"distributions_heading_ranks": "Rang Szint Bontás",
"distributions_heading_mmr": "Egyéni MMR Bontás",
"distributions_heading_country_mmr": "Átlagos Egyéni MMR Ország Szerint",
"distributions_tab_ranks": "Rang Szint ",
"distributions_tab_mmr": "Egyéni MMR",
"distributions_tab_country_mmr": "Egyéni MMR Ország Szerint",
"distributions_warning_1": "Ezek az adatok korlátozva vannak azon játékosokra akok profiljukban kijelzik az MMR-t és megosztják a publikus mérkőzés adatokat.",
"distributions_warning_2": "A játékosoknak nem szükséges bejelentkezniük, de a gyűjtött adatok engedélyezett természete miatt az átlagok a vártnál magasabbak lehetnek.",
"error": "Hiba",
"error_message": "Hoppá! Valami baj történt.",
"error_four_oh_four_message": "A keresett oldal nem található.",
"explorer_title": "Felfedező",
"explorer_subtitle": "Professzionális Dota 2 Adatok",
"explorer_description": "Öszetett keresés professzionális mérkőzésekben (az amatőr ligák ki vannak szűrve)",
"explorer_schema": "Séma",
"explorer_results": "Eredmények",
"explorer_num_rows": "sor(ok)",
"explorer_select": "Szűrés",
"explorer_group_by": "Csoportosítás",
"explorer_hero": "Hős",
"explorer_patch": "Verzió",
"explorer_min_patch": "Min Verzió",
"explorer_max_patch": "Max Verzió",
"explorer_min_mmr": "Min MMR",
"explorer_max_mmr": "Max MMR",
"explorer_min_rank_tier": "Min Szint",
"explorer_max_rank_tier": "Max Szint",
"explorer_player": "Játékos",
"explorer_league": "Liga",
"explorer_player_purchased": "Megvásárolva",
"explorer_duration": "Időtartam",
"explorer_min_duration": "Min Időtartam",
"explorer_max_duration": "Max Időtartam",
"explorer_timing": "Időzítés",
"explorer_uses": "Használat",
"explorer_kill": "Ölési Idő",
"explorer_side": "Oldal",
"explorer_toggle_sql": "Váltás SQL-re",
"explorer_team": "Csapat",
"explorer_lane_role": "Vonal",
"explorer_min_date": "Min Dátum",
"explorer_max_date": "Max Dátum",
"explorer_hero_combos": "Hős Kombinációk",
"explorer_hero_player": "Hős-Játékos",
"explorer_player_player": "Játékos-Játékos",
"explorer_sql": "SQL",
"explorer_postgresql_function": "PostgreSQL Funkció",
"explorer_table": "Tábla",
"explorer_column": "Oszlop",
"explorer_query_button": "Tábla",
"explorer_cancel_button": "Mégse",
"explorer_table_button": "Tábla",
"explorer_api_button": "API",
"explorer_json_button": "JSON",
"explorer_csv_button": "CSV",
"explorer_donut_button": "Donut",
"explorer_bar_button": "Bar",
"explorer_timeseries_button": "Timeseries",
"explorer_chart_unavailable": "A táblázat nem elérhető, próbáld meg a CSOPORTOSÍTÁS-t",
"explorer_value": "Érték",
"explorer_category": "Kategória",
"explorer_region": "Régió",
"explorer_picks_bans": "Választás/Tiltás",
"explorer_counter_picks_bans": "Ellen-Választás/Tiltás",
"explorer_organization": "Szervezet",
"explorer_order": "Rendezés",
"explorer_asc": "Növekvő",
"explorer_desc": "Csökkenő",
"explorer_tier": "Szint",
"explorer_having": "Legalább ennnyi mérkőzés",
"explorer_limit": "Limit",
"explorer_match": "Mérkőzés",
"explorer_is_ti_team": "TI{number} Csapat",
"explorer_mega_comeback": "Mega Creepek ellen nyert",
"explorer_max_gold_adv": "Max Arany Különbség",
"explorer_min_gold_adv": "Min Arany Különbség",
"farm_heroes": "Hősök megölve",
"farm_creeps": "Vonali creepek megölve",
"farm_neutrals": "Semleges creepek megölve (beleértve az Ősöket)",
"farm_ancients": "Ős creepek megölve",
"farm_towers": "Tornyok lerombolva",
"farm_couriers": "Futárok megölve",
"farm_observers": "Figyelő wardok megölve",
"farm_sentries": "Őrszem wardok megölve",
"farm_roshan": "Roshan megölve",
"farm_necronomicon": "Necronomicon egységek megölve",
"filter_button_text_open": "Szűrés",
"filter_button_text_close": "Bezárás",
"filter_hero_id": "Hős",
"filter_is_radiant": "Oldal",
"filter_win": "Eredmény",
"filter_lane_role": "Vonal",
"filter_patch": "Verzió",
"filter_game_mode": "Játékmód",
"filter_lobby_type": "Váró Típusa",
"filter_date": "Dátum",
"filter_region": "Régió",
"filter_with_hero_id": "Szövetséges Hősök",
"filter_against_hero_id": "Ellenfél Hősök",
"filter_included_account_id": "Szerepeljen a fiók ID",
"filter_excluded_account_id": "Ne szerepeljen benne a fiók ID",
"filter_significant": "Jelentéktelen",
"filter_significant_include": "Tartzalmazza",
"filter_last_week": "Múlt hét",
"filter_last_month": "Múlt hónap",
"filter_last_3_months": "Utóbbi 3 hónap",
"filter_last_6_months": "Elmúlt fél év",
"filter_last_12_months": "Elmúlt 12 hónap",
"filter_error": "Válassz egy elemet a listából",
"filter_party_size": "Csapat méret",
"game_mode_0": "Ismeretlen",
"game_mode_1": "Szabad Választás",
"game_mode_2": "Kapitány Mód",
"game_mode_3": "Véletlen Választás",
"game_mode_4": "Single Draft",
"game_mode_5": "Mindenki Véletlenszerű",
"game_mode_6": "Bevezető",
"game_mode_7": "Diretide",
"game_mode_8": "Fordított Kapitány Mód",
"game_mode_9": "The Greeviling",
"game_mode_10": "Oktatás",
"game_mode_11": "Csak Középső",
"game_mode_12": "Legkevesebbet Játszott",
"game_mode_13": "Korlátozott Hősök",
"game_mode_14": "Összefoglaló",
"game_mode_15": "Egyedi",
"game_mode_16": "Kapitány Választás",
"game_mode_17": "Egyensúlyozott Választás",
"game_mode_18": "Képesség Választás",
"game_mode_19": "Esemény",
"game_mode_20": "Mindenki Véletlenszerű Élet-Halál Játszma",
"game_mode_21": "Egy az Egy Ellen",
"game_mode_22": "Minden Választás",
"game_mode_23": "Turbó",
"game_mode_24": "Mutáció",
"general_unknown": "Ismeretlen",
"general_no_hero": "Nincs hős",
"general_anonymous": "Névtelen",
"general_radiant": "Radiant",
"general_dire": "Dire",
"general_standard_deviation": "Alapvető Eltérés",
"general_matches": "Mérkőzések",
"general_league": "Ligák",
"general_randomed": "Véletlenszerű",
"general_repicked": "Újraválasztott",
"general_predicted_victory": "Megjósolt győzelem",
"general_show": "Mutat",
"general_hide": "Elrejt",
"gold_reasons_0": "Egyéb",
"gold_reasons_1": "Halál",
"gold_reasons_2": "Visszavétel",
"NULL_gold_reasons_5": "Elhagyás",
"NULL_gold_reasons_6": "Eladás",
"gold_reasons_11": "Épület",
"gold_reasons_12": "Hős",
"gold_reasons_13": "Creep",
"gold_reasons_14": "Roshan",
"NULL_gold_reasons_15": "Futár",
"header_request": "Kérés",
"header_distributions": "Rangsor",
"header_heroes": "Hősök",
"header_blog": "Blog",
"header_ingame": "Játékbeli",
"header_matches": "Mérkőzések",
"header_records": "Rekordok",
"header_explorer": "Felfedező",
"header_teams": "Csapatok",
"header_meta": "Meta",
"header_scenarios": "Forgatókönyvek",
"header_api": "API",
"heading_lhten": "Utolsó Találat @ 10",
"heading_lhtwenty": "Utolsó Találat @ 20",
"heading_lhthirty": "Utolsó Találat @ 30",
"heading_lhforty": "Utolsó Találat @ 40",
"heading_lhfifty": "Utolsó Találat @ 50",
"heading_courier": "Futár",
"heading_roshan": "Roshan",
"heading_tower": "Torony",
"heading_barracks": "Barakkok",
"heading_shrine": "Oltár",
"heading_item_purchased": "Tárgy Megvéve",
"heading_ability_used": "Képesség Használva",
"heading_item_used": "Tárgy Használva",
"heading_damage_inflictor": "Sebzést okozó",
"heading_damage_inflictor_received": "Sebzést okozó elszenvedés",
"heading_damage_instances": "Sebzés fajták",
"heading_camps_stacked": "Halmozott táborok",
"heading_matches": "Legutóbbi mérkőzések",
"heading_heroes": "Legtöbbet játszott hősök",
"heading_mmr": "MMR Történet",
"heading_peers": "Játékosok akikkel játszott",
"heading_pros": "Profi játékosok akikkel játszott",
"heading_rankings": "Hős Rangsor",
"heading_all_matches": "Összes Mérkőzésben",
"heading_parsed_matches": "Elemzett Mérkőzésekben",
"heading_records": "Rekordok",
"heading_teamfights": "Csapatharcok",
"heading_graph_difference": "Radiant Előny",
"heading_graph_gold": "Arany",
"heading_graph_xp": "Tapasztalat",
"heading_graph_lh": "Utolsó Találatok",
"heading_graph_cs": "Utolsó Találat + Beáldozás",
"heading_overview": "Áttekintés",
"heading_ability_draft": "Képességek Választva",
"heading_buildings": "Épületek",
"heading_benchmarks": "Értékek",
"heading_laning": "Vonal",
"heading_overall": "Átfogó",
"heading_kills": "Ölések",
"heading_deaths": "Halálok",
"heading_assists": "Segítségek",
"heading_damage": "Sebzés",
"heading_unit_kills": "Egység Ölések",
"heading_last_hits": "Utolsó Találatok",
"heading_gold_reasons": "Arany Források",
"heading_xp_reasons": "Tapasztalat Források",
"heading_performances": "Teljesítmények",
"heading_support": "Támogatás",
"heading_purchase_log": "Vásárlási Történet",
"heading_casts": "Használatok",
"heading_objective_damage": "Cél Sebzés",
"heading_runes": "Rúnák",
"heading_vision": "Láthatóság",
"heading_actions": "Cselekmények",
"heading_analysis": "Elemzés",
"heading_cosmetics": "Külsőségek",
"heading_log": "Jegyzőkönyv",
"heading_chat": "Csevegés",
"heading_story": "Törénet",
"heading_fantasy": "Fantázia",
"heading_wardmap": "Ward térkép",
"heading_wordcloud": "Szófelhő",
"heading_wordcloud_said": "Szavak kimondva (minden csevegés)",
"heading_wordcloud_read": "Szavak olvasva (minden csevegés)",
"heading_kda": "ÖHS",
"heading_gold_per_min": "Percenkénti Arany",
"heading_xp_per_min": "Percenkénti Tapasztalat",
"heading_denies": "Beáldozás",
"heading_lane_efficiency_pct": "VH@10",
"heading_duration": "Időtartam",
"heading_level": "Szint",
"heading_hero_damage": "Hős Sebzés",
"heading_tower_damage": "Torony Sebzés",
"heading_hero_healing": "Hős Gyógyítás",
"heading_tower_kills": "Torony Rombolás",
"heading_stuns": "Bénítás",
"heading_neutral_kills": "Semleges Ölés",
"heading_courier_kills": "Futár Ölés",
"heading_purchase_tpscroll": "Portál Tekercs Vásárolva",
"heading_purchase_ward_observer": "Figyelő Ward Vásárolva",
"heading_purchase_ward_sentry": "Őrszem Ward Vásárolva",
"heading_purchase_gem": "Drágakő Vásárolva",
"heading_purchase_rapier": "Divine Rapier Megvásárolva",
"heading_pings": "Térkép Pingelések",
"heading_throw": "Dobás",
"heading_comeback": "Visszajövetel",
"heading_stomp": "Taposás",
"heading_loss": "Veszteség",
"heading_actions_per_min": "Percenkénti Cselekvés",
"heading_leaver_status": "Elhagyó Állapot",
"heading_game_mode": "Játékmód",
"heading_lobby_type": "Váró Típus",
"heading_lane_role": "Vonal Szerep",
"heading_region": "Régió",
"heading_patch": "Verzió",
"heading_win_rate": "Nyerési Arány",
"heading_is_radiant": "Oldal",
"heading_avg_and_max": "Átlag/Maximum",
"heading_total_matches": "Összes Mérkőzés",
"heading_median": "Középérték",
"heading_distinct_heroes": "Különböző Hősök",
"heading_team_elo_rankings": "Csapat Rangsorok az Elo osztályozás szerint",
"heading_ability_build": "Képességek",
"heading_attack": "Alap Támadás",
"heading_attack_range": "Támadási Távolság",
"heading_attack_speed": "Támadási Sebesség",
"heading_projectile_speed": "Lövedék Sebesség",
"heading_base_health": "Életerő",
"heading_base_health_regen": "Életerő Töltés",
"heading_base_mana": "Mana",
"heading_base_mana_regen": "Mana Töltés",
"heading_base_armor": "Alap Páncél",
"heading_base_mr": "Varázslat Ellenállás",
"heading_move_speed": "Mozgási Sebesség",
"heading_turn_rate": "Fordulási Sebesség",
"heading_legs": "Lábak Száma",
"heading_cm_enabled": "Kapitány módban",
"heading_current_players": "Játékoskeret",
"heading_former_players": "Korábbi játékosok",
"heading_damage_dealt": "Okozott Sebzés",
"heading_damage_received": "Kapott Sebzés",
"show_details": "Mutasd a részleteket",
"hide_details": "Rejtsd el a részleteket",
"subheading_avg_and_max": "az elmúlt {0} mutatott mérkőzésen",
"subheading_records": "Rangsorolt mérkőzéseken. Havonta visszaállítva.",
"subheading_team_elo_rankings": "k=32, init=1000",
"hero_pro_tab": "Professzionális",
"hero_public_tab": "Publikus",
"hero_pro_heading": "Hősök a Profi Mérkőzéseken",
"hero_public_heading": "Hősök a Publikus Mérkőzéseken (Minta)",
"hero_this_month": "az elmúlt 30 nap mérkőzései",
"hero_pick_ban_rate": "Profi V+T%",
"hero_pick_rate": "Profi Választás%",
"hero_ban_rate": "Profi Tiltás%",
"hero_win_rate": "Profi Győzelem%",
"hero_5000_pick_rate": ">5K V%",
"hero_5000_win_rate": ">5K Gy%",
"hero_4000_pick_rate": "4K V%",
"hero_4000_win_rate": "4K Gy%",
"hero_3000_pick_rate": "3K V%",
"hero_3000_win_rate": "3K Gy%",
"hero_2000_pick_rate": "2K V%",
"hero_2000_win_rate": "2K Gy%",
"hero_1000_pick_rate": "<2K V%",
"hero_1000_win_rate": "<2K Gy%",
"home_login": "Jelentkezz be",
"home_login_desc": "az automata visszajátszás elemzéshez",
"home_parse": "Nézz meg",
"home_parse_desc": "egy általad választott mérkőzést",
"home_why": "",
"home_opensource_title": "Nyílt Forráskód",
"home_opensource_desc": "A projekt teljes kódja nyílt forráskódú, hogy a közreműködők fejleszthessék és módosíthassák.",
"home_indepth_title": "Mélyreható Adatok",
"home_indepth_desc": "Az elemzett visszajátszások magasan részletezett adatokat biztosítanak.",
"home_free_title": "Díjmentes",
"home_free_desc": "A szervereket a támogatók és önkéntesek tartják fent, így a szolgáltatás díjmentes.",
"home_background_by": "Háttérképet készítette",
"home_sponsored_by": "Támogatja",
"home_become_sponsor": "Legyél Támogató",
"include_turbo_matches": "Turbó mérkőzéskkel együtt",
"items_name": "Tárgy neve",
"items_built": "Ennyiszer rakták össze",
"items_matches": "Ennyi mérkőzésen rakták össze",
"items_uses": "Ennyiszer használták",
"items_uses_per_match": "Átlagosan ennyiszer használták azon a mérkőzésen ahol összerakták",
"items_timing": "Átlagosan ekkor rakták össze",
"items_build_pct": "Százalékosan ennyi mérkőzésen rakták össze",
"items_win_pct": "Százalékosan megnyert mérkőzések ahol összerakták",
"lane_role_0": "Ismeretlen",
"lane_role_1": "Biztonságos",
"lane_role_2": "Középső",
"lane_role_3": "Szélső",
"lane_role_4": "Dzsungel",
"lane_pos_1": "Alsó",
"lane_pos_2": "Középső",
"lane_pos_3": "Felső",
"lane_pos_4": "Radiant Dzsungel",
"lane_pos_5": "Dire Dzsungel",
"leaver_status_0": "Nincs",
"leaver_status_1": "Biztosnságos",
"leaver_status_2": "Elhagyás (Lecsatlakozás)",
"leaver_status_3": "Elhagyás",
"leaver_status_4": "Elhagyás (Nincs gépnél)",
"leaver_status_5": "Nem Csatlakozott",
"leaver_status_6": "Nem Csatlakozott (Időtúllépés)",
"lobby_type_0": "Normál",
"lobby_type_1": "Gyakorló",
"lobby_type_2": "Bajnokság",
"lobby_type_3": "Bevezető",
"lobby_type_4": "Együttműködő Botok",
"lobby_type_5": "Rangsorolt Csapat Mérkőzés Keresés (Elavult)",
"lobby_type_6": "Rangsorolt Egyéni Mérkőzés Keresés (Elavult)",
"lobby_type_7": "Rangsorolt",
"lobby_type_8": "1 az 1 Ellen",
"lobby_type_9": "Csata Kupa",
"match_radiant_win": "Radiant Győzelem",
"match_dire_win": "Dire Győzelem",
"match_team_win": "Győzelem",
"match_ended": "Befejezve",
"match_id": "Mérkőzés azonosító",
"match_region": "Régió",
"match_avg_mmr": "Átlag MMR",
"match_button_parse": "Elemzés",
"match_button_reparse": "Újra elemzés",
"match_button_replay": "Visszajátszás",
"match_button_video": "Videó beszerzése",
"match_first_tower": "Első torony",
"match_first_barracks": "Első barakk",
"match_pick": "Vál.",
"match_ban": "Tilt",
"matches_highest_mmr": "Top Publikus",
"matches_lowest_mmr": "Alacsony MMR",
"meta_title": "Meta",
"meta_description": "Futtass összetett keresést az elmúlt 24 óra elemzett adataiból",
"mmr_not_up_to_date": "Miért nem friss az MMR?",
"npc_dota_beastmaster_boar_#": "Vadkan",
"npc_dota_lesser_eidolon": "Gyenge Eidolon",
"npc_dota_eidolon": "Eidolon",
"npc_dota_greater_eidolon": "Erős Eidolon",
"npc_dota_dire_eidolon": "Dire Eidolon",
"npc_dota_invoker_forged_spirit": "Forged Spirit",
"npc_dota_furion_treant_large": "Hatalmas Treant",
"npc_dota_beastmaster_hawk_#": "Sólyom",
"npc_dota_lycan_wolf#": "Lycan Farkas",
"npc_dota_neutral_mud_golem_split_doom": "Doom Töredék",
"npc_dota_broodmother_spiderling": "Spiderling",
"npc_dota_broodmother_spiderite": "Spiderite",
"npc_dota_furion_treant": "Treant",
"npc_dota_unit_undying_zombie": "Undying Zombi",
"npc_dota_unit_undying_zombie_torso": "Undying Zombi",
"npc_dota_brewmaster_earth_#": "Föld Brewling",
"npc_dota_brewmaster_fire_#": "Tűz Brewling",
"npc_dota_lone_druid_bear#": "Lélek Medve",
"npc_dota_brewmaster_storm_#": "Vihar Brewling",
"npc_dota_visage_familiar#": "Familiáris",
"npc_dota_warlock_golem_#": "Warlock Gólem",
"npc_dota_warlock_golem_scepter_#": "Warlock Gólem",
"npc_dota_witch_doctor_death_ward": "Halál Ward",
"npc_dota_tusk_frozen_sigil#": "Fagyott Pecsét",
"npc_dota_juggernaut_healing_ward": "Gyógyító Ward",
"npc_dota_techies_land_mine": "Taposóakna",
"npc_dota_shadow_shaman_ward_#": "Kígyó Ward",
"npc_dota_pugna_nether_ward_#": "Alvilági Ward",
"npc_dota_venomancer_plague_ward_#": "Pestis Ward",
"npc_dota_rattletrap_cog": "Elektromos Fogaskerék",
"npc_dota_templar_assassin_psionic_trap": "Pszionikus Csapda",
"npc_dota_techies_remote_mine": "Távirányítású Akna",
"npc_dota_techies_stasis_trap": "Sztázis Csapda",
"npc_dota_phoenix_sun": "Szupernova",
"npc_dota_unit_tombstone#": "Sírkő",
"npc_dota_treant_eyes": "Az Erdő Szemei",
"npc_dota_gyrocopter_homing_missile": "Hőkövető Rakéta",
"npc_dota_weaver_swarm": "A Raj",
"objective_tower1_top": "F1",
"objective_tower1_mid": "K1",
"objective_tower1_bot": "A1",
"objective_tower2_top": "F2",
"objective_tower2_mid": "K2",
"objective_tower2_bot": "A2",
"objective_tower3_top": "F3",
"objective_tower3_mid": "K3",
"objective_tower3_bot": "A3",
"objective_rax_top": "BarF",
"objective_rax_mid": "BarK",
"objective_rax_bot": "BarA",
"objective_tower4": "T4",
"objective_fort": "Ős",
"objective_shrine": "Oltár",
"objective_roshan": "Roshan",
"tooltip_cs_over_time": "Percenkénti Creep Pont, az első 10 percben",
"tooltip_dotaplus": "Dota Plus előfizető",
"tooltip_hero_rankings_score": "A pont minden győzelem után nő és minden vesztes mérkőzés után csökken. A pontok meccsen belüli átlag MMR alapján számolandók.",
"tooltip_objective_tower1_top": "Sebzés az 1. Szintű Felső toronyra",
"tooltip_objective_tower1_mid": "Sebzés az 1. Szintű Középső toronyra",
"tooltip_objective_tower1_bot": "Sebzés az 1. Szintű Alsó toronyra",
"tooltip_objective_tower2_top": "Sebzés a 2. Szintű Felső toronyra",
"tooltip_objective_tower2_mid": "Sebzés a 2. Szintű Középső toronyra",
"tooltip_objective_tower2_bot": "Sebzés a 2. Szintű Alsó toronyra",
"tooltip_objective_tower3_top": "Sebzés a 3. Szintű Felső toronyra",
"tooltip_objective_tower3_mid": "Sebzés a 3. Szintű Középső toronyra",
"tooltip_objective_tower3_bot": "Sebzés a 3. Szintű Alsó toronyra",
"tooltip_objective_rax_top": "Sebzés a Felső barakkokra",
"tooltip_objective_rax_mid": "Sebzés a Középső barakkokra",
"tooltip_objective_rax_bot": "Sebzés az Alsó barakkokra",
"tooltip_objective_tower4": "Sebzés a 4. Szintű Középső tornyokra",
"tooltip_objective_fort": "Sebzés az Ősön",
"tooltip_objective_shrine": "Sebzés oltárokon",
"tooltip_objective_roshan": "Sebzés Roshanon",
"pagination_first": "Első",
"pagination_last": "Utolsó",
"pagination_of": "| Összesen",
"peers_none": "Ennek a játékosnak nincsenek társai.",
"rank_tier_0": "Kalibrálatlan",
"rank_tier_1": "Hírnök",
"rank_tier_2": "Őrző",
"rank_tier_3": "Kersztes",
"rank_tier_4": "Arkhón",
"rank_tier_5": "Legenda",
"rank_tier_6": "Ős",
"rank_tier_7": "Isteni",
"rank_tier_8": "Hallhatatlan",
"request_title": "Elemzés Kérése",
"request_match_id": "Mérkőzés azonosító",
"request_invalid_match_id": "Hibás mérkőzés azonosító",
"request_error": "Nem sikerült a mérkőzés adatok betöltése",
"request_submit": "Elküld",
"roaming": "Ingázó",
"rune_0": "Dupla sebzés",
"rune_1": "Sietség",
"rune_2": "Illúzió",
"rune_3": "Láthatatlanság",
"rune_4": "Regeneráció",
"rune_5": "Adomány",
"rune_6": "Misztikus",
"rune_7": "Víz",
"search_title": "Keresés meccs ID vagy név alapján...",
"skill_0": "Ismeretlen Szint",
"skill_1": "Normál Szint",
"skill_2": "Magas Szint",
"skill_3": "Nagyon Magas Szint",
"story_invalid_template": "(hibás sablon)",
"story_error": "Hiba történt a mérközés történetének feldolgozása közben",
"story_intro": "{date}, úgy döntött, hogy játszik egy {game_mode_article} {game_mode} Dota 2 mérkőzést a {region} régióban. Nem gondolták volna, hogy a játék {duration_in_words} tart mire végetér",
"story_invalid_hero": "Ismeretlen Hős",
"story_fullstop": ".",
"story_list_2": "{1} és {2}",
"story_list_3": "{1}, {2}, és {3}",
"story_list_n": "{i}, {rest}",
"story_firstblood": "az első vérontást {killer} követte el {victim} ellen {time}-kor",
"story_chatmessage": "\"{message}\", {said_verb} {player}",
"story_teamfight": "{winning_team} megnyerte a csapatharcot ami {win_dead} áldozatát követelte az ellenséges {lose_dead} életért, ennek eredményeként a csapat nettó érték növekedése {net_change}",
"story_teamfight_none_dead": "{winning_team} megynerte a csapatharcot, megölve {lose_dead} ellenséget anélkül, hogy bárkit elvesztettek volna, ennek eredményeképpen a csapat nettó érték növekedése {net_change}",
"story_teamfight_none_dead_loss": "{winning_team} valahogy nyert egy csapatharcot anélkül,hogy bárkit is megölt volna, {win_dead} elvesztése árán, ennek eredményeként a csapat nettó érték növekedése {net_change}",
"story_lane_intro": "10 perc játékidő után az állás a következő:",
"story_lane_radiant_win": "{radiant_players} megnyerte {lane} vonalat {dire_players} ellen",
"story_lane_radiant_lose": "{radiant_players} elvesztette {lane} vonalat {dire_players} ellen",
"story_lane_draw": "{radiant_players} döntetlenre hozta ki {lane} vonalat még {dire_players} ellen is",
"story_lane_free": "{players} szabadon van {lane} vonalon",
"story_lane_empty": "senki nem volt {lane} vonalon",
"story_lane_jungle": "{players} a dzsungleben farmolt",
"story_lane_roam": "{players} ingázott",
"story_roshan": "{team} megölte Roshant",
"story_aegis": "{player} {action} az Aegist",
"story_gameover": "A mérkőzés {winning_team} győzelmével zárult {duration} alatt. Az eredmények: {radiant_score} | {dire_score}",
"story_during_teamfight": "a harc alatt, {events}",
"story_after_teamfight": "a harc után, {events}",
"story_expensive_item": "{time}-kor, {player} megvette {item}, ami az első tárgy volt, melynek értéke nagyobb, mint {price_limit}",
"story_building_destroy": "{building} le lett rombolva",
"story_building_destroy_player": "{player} által {building} le lett rombolva",
"story_building_deny_player": "{player} által {building} be lett áldozva",
"story_building_list_destroy": "{buildings} le lett rombolva",
"story_courier_kill": "A {team} futárját megölték",
"story_tower": "{team} {tier}. Szintű {lane} tornya",
"story_tower_simple": "a {team} tornya",
"story_towers_n": "{n} a {team} tornyaiból",
"story_barracks": "{team} {lane} {rax_type}",
"story_barracks_both": "a {team} csapat mindkét {lane} barakkja",
"story_time_marker": "{minutes} perce",
"story_item_purchase": "{player} megvette {item}-t {time}-kor",
"story_predicted_victory": "{players} megjósolta, hogy a {team} fog nyerni",
"story_predicted_victory_empty": "Senki",
"story_networth_diff": "{percent}% / {gold} Különbség",
"story_gold": "arany",
"story_chat_asked": "kérdezte",
"story_chat_said": "mondta",
"tab_overview": "Áttekintés",
"tab_matches": "Mérkőzések",
"tab_heroes": "Hősök",
"tab_peers": "Társak",
"tab_pros": "Profik",
"tab_activity": "Aktivítás",
"tab_records": "Rekordok",
"tab_totals": "Összesítés",
"tab_counts": "Adatok",
"tab_histograms": "Hisztogram",
"tab_trends": "Tendencia",
"tab_items": "Tárgyak",
"tab_wardmap": "Ward Térkép",
"tab_wordcloud": "Szófelhő",
"tab_mmr": "MMR",
"tab_rankings": "Rangsorolás",
"tab_drafts": "Választás",
"tab_benchmarks": "Mérések",
"tab_performances": "Teljesítmény",
"tab_damage": "Sebzés",
"tab_purchases": "Vásárlás",
"tab_farm": "Farm",
"tab_combat": "Harc",
"tab_graphs": "Grafikonok",
"tab_casts": "Használat",
"tab_vision": "Láthatóság",
"tab_objectives": "Célok",
"tab_teamfights": "Csapatharcok",
"tab_actions": "Cselekvések",
"tab_analysis": "Elemzések",
"tab_cosmetics": "Külsőségek",
"tab_log": "Jegyzőkönyv",
"tab_chat": "Csevegés",
"tab_story": "Történet",
"tab_fantasy": "Fantázia",
"tab_laning": "Vonal",
"tab_recent": "Legutóbbi",
"tab_matchups": "Felállás",
"tab_durations": "Időtartam",
"tab_players": "Játékosok",
"placeholder_filter_heroes": "Hősök szűrése",
"td_win": "Megnyert Mérkőzés",
"td_loss": "Elvesztett Mérkőzés",
"td_no_result": "Nincs Eredmény",
"th_hero_id": "Hős",
"th_match_id": "Azonosító",
"th_account_id": "Fiók azonosító",
"th_result": "Eredmény",
"th_skill": "Szint",
"th_duration": "Időtartam",
"th_games": "JJ",
"th_games_played": "Mérkőzések",
"th_win": "Nyert %",
"th_advantage": "Előny",
"th_with_games": "Vele",
"th_with_win": "Megnyerte vele %",
"th_against_games": "Ellene",
"th_against_win": "Megnyerte ellene %",
"th_gpm_with": "APP Vele",
"th_xpm_with": "TPP Vele",
"th_avatar": "Player",
"th_last_played": "Legutóbbi",
"th_record": "Rekord",
"th_title": "Cím",
"th_category": "Kategória",
"th_matches": "Mérkőzések",
"th_percentile": "Százalékos",
"th_rank": "Rang",
"th_items": "Tárgyak",
"th_stacked": "Halmozott",
"th_multikill": "Többszörös ölés",
"th_killstreak": "Folyamatos ölés",
"th_stuns": "Bénítás",
"th_dead": "Meghalt",
"th_buybacks": "Visszavétel",
"th_biggest_hit": "Legnagyobb csapás",
"th_lane": "Vonal",
"th_map": "Térkép",
"th_lane_efficiency": "VH@10",
"th_lhten": "LH@10",
"th_dnten": "BÁ@10",
"th_tpscroll": "TP",
"th_ward_observer": "Figyelő",
"th_ward_sentry": "Őrszem",
"th_smoke_of_deceit": "Füst",
"th_dust": "Por",
"th_gem": "Drágakő",
"th_time": "Idő",
"th_message": "Üzenet",
"th_heroes": "Hősök",
"th_creeps": "Creepek",
"th_neutrals": "Semlegesek",
"th_ancients": "Ősök",
"th_towers": "Tornyok",
"th_couriers": "Futárok",
"th_roshan": "Roshan",
"th_necronomicon": "Nekronomikon",
"th_other": "Egyéb",
"th_cosmetics": "Külsőség",
"th_damage_received": "Kapott",
"th_damage_dealt": "Adott",
"th_players": "Játékosok",
"th_analysis": "Elemzés",
"th_death": "Halál",
"th_damage": "Sebzés",
"th_healing": "Gyógyítás",
"th_gold": "A",
"th_xp": "TP",
"th_abilities": "Képességek",
"th_target_abilities": "Képesség Célok",
"th_mmr": "MMR",
"th_level": "SZ",
"th_kills": "Ö",
"th_kills_per_min": "ÖPP",
"th_deaths": "H",
"th_assists": "S",
"th_last_hits": "UT",
"th_last_hits_per_min": "UTPP",
"th_denies": "BÁ",
"th_gold_per_min": "APP",
"th_xp_per_min": "TPP",
"th_stuns_per_min": "BPP",
"th_hero_damage": "HS",
"th_hero_damage_per_min": "HSPP",
"th_hero_healing": "HGY",
"th_hero_healing_per_min": "HGYPP",
"th_tower_damage": "TS",
"th_tower_damage_per_min": "TSPP",
"th_kda": "ÖHS",
"th_actions_per_min": "CSPP",
"th_pings": "PNG (M)",
"th_DOTA_UNIT_ORDER_MOVE_TO_POSITION": "MOZ (P)",
"th_DOTA_UNIT_ORDER_MOVE_TO_TARGET": "MOZ (C)",
"th_DOTA_UNIT_ORDER_ATTACK_TARGET": "TÁM (C)",
"th_DOTA_UNIT_ORDER_ATTACK_MOVE": "TÁM (P)",
"th_DOTA_UNIT_ORDER_CAST_POSITION": "HASZ (P)",
"th_DOTA_UNIT_ORDER_CAST_TARGET": "HASZ (C)",
"th_DOTA_UNIT_ORDER_CAST_NO_TARGET": "HASZN (N)",
"th_DOTA_UNIT_ORDER_HOLD_POSITION": "TART",
"th_DOTA_UNIT_ORDER_GLYPH": "VÉD",
"th_DOTA_UNIT_ORDER_RADAR": "SZKEN",
"th_ability_builds": "KÉ",
"th_purchase_shorthand": "VÁS",
"th_use_shorthand": "HASZ",
"th_duration_shorthand": "IDŐ",
"th_country": "Ország",
"th_count": "Szám",
"th_sum": "Összeg",
"th_average": "Átlag",
"th_name": "Név",
"th_team_name": "csapat név",
"th_score": "Pontok",
"th_casts": "Használatok",
"th_hits": "Találatok",
"th_wins": "Győzelmek",
"th_losses": "Vereségek",
"th_winrate": "Győzelmi arány",
"th_solo_mmr": "Egyéni MMR",
"th_party_mmr": "Társas MMR",
"th_estimated_mmr": "Számított MMR",
"th_permanent_buffs": "Érősítések",
"th_winner": "Győztes",
"th_played_with": "Rekordom vele",
"th_obs_placed": "Figyelő wardok elhelyezve",
"th_sen_placed": "Őrszem wardok elhelyezve",
"th_obs_destroyed": "Figyelő wardok elpusztítva",
"th_sen_destroyed": "Őrszem wardok elpusztítva",
"th_scans_used": "Szkennelés használva",
"th_glyphs_used": "Védelem használva",
"th_legs": "Lábak",
"th_fantasy_points": "Fantázia Pontok",
"th_rating": "Értékelés",
"th_teamfight_participation": "Részvétel",
"th_firstblood_claimed": "Első Vérontás",
"th_observers_placed": "Wardok",
"th_camps_stacked": "Halmozások",
"th_league": "Liga",
"th_attack_type": "Támadás típus",
"th_primary_attr": "Elsődleges tulajdonság",
"th_opposing_team": "Ellenfél Csapat",
"ward_log_type": "Típus",
"ward_log_owner": "Tulajdonos",
"ward_log_entered_at": "Elhelyezve",
"ward_log_left_at": "Eltűnt",
"ward_log_duration": "Élettartam",
"ward_log_killed_by": "Elpusztította",
"log_detail": "Részletek",
"log_heroes": "Hős meghatározás",
"tier_professional": "Professzionális",
"tier_premium": "Prémium",
"time_past": "{0}",
"time_just_now": "éppen most",
"time_s": "egy másodperce",
"time_abbr_s": "{0}mp",
"time_ss": "{0} másodperce",
"time_abbr_ss": "{0}mp",
"time_m": "egy perce",
"time_abbr_m": "{0}p",
"time_mm": "{0} perce",
"time_abbr_mm": "{0}p",
"time_h": "egy órája",
"time_abbr_h": "{0}ó",
"time_hh": "{0} órája",
"time_abbr_hh": "{0}ó",
"time_d": "egy napja",
"time_abbr_d": "{0}n",
"time_dd": "{0} napja",
"time_abbr_dd": "{0}n",
"time_M": "egy hónapja",
"time_abbr_M": "{0}h",
"time_MM": "{0} hónapja",
"time_abbr_MM": "{0}k",
"time_y": "egy éve",
"time_abbr_y": "{0}é",
"time_yy": "{0} éve",
"time_abbr_yy": "{0}é",
"timeline_firstblood": "követte el az első vérontást",
"timeline_firstblood_key": "követte el az első vérontást, megölve",
"timeline_aegis_picked_up": "felvette",
"timeline_aegis_snatched": "ellopta",
"timeline_aegis_denied": "beáldozta",
"timeline_teamfight_deaths": "Halálok",
"timeline_teamfight_gold_delta": "gold delta",
"title_default": "OpenDota - Dota 2 Statisztikák",
"title_template": "%s - OpenDota - Dota 2 Statisztikák",
"title_matches": "Mérkőzések",
"title_request": "Elemzés Igénylése",
"title_search": "Keresés",
"title_status": "Állapot",
"title_explorer": "Adat Felfedező",
"title_meta": "Meta",
"title_records": "Rekordok",
"title_api": "Opendota API: Összetett Dota 2 statisztikák az appodhoz",
"tooltip_mmr": "Ennek a játékosnak az Egyéni MMR értéke",
"tooltip_abilitydraft": "Választott Képesség",
"tooltip_level": "A hős által elért szint",
"tooltip_kills": "A hős öléseinek száma",
"tooltip_deaths": "A hős halálainak száma",
"tooltip_assists": "A hős segítségeinek száma",
"tooltip_last_hits": "A hős utolsó találatainak száma",
"tooltip_denies": "Beáldozott creepek száma",
"tooltip_gold": "Összes farmolt arany",
"tooltip_gold_per_min": "Farmolt arany percenként",
"tooltip_xp_per_min": "Tapasztalat szerezve percenként",
"tooltip_stuns_per_min": "Percenkénti hős bénítás másodpercei",
"tooltip_last_hits_per_min": "Percenkénti utolsó találat",
"tooltip_kills_per_min": "Percenkénti ölés",
"tooltip_hero_damage_per_min": "Percenkénti hős sebzés",
"tooltip_hero_healing_per_min": "Percenkénti hős bénítás",
"tooltip_tower_damage_per_min": "Percenkénti torony sebzés",
"tooltip_actions_per_min": "Játékos cselekvés percenként",
"tooltip_hero_damage": "Hősökre mért sebzés mértéke",
"tooltip_tower_damage": "Tornyokra mért sebzés mértéke",
"tooltip_hero_healing": "Viszaállított életerő mértéke",
"tooltip_duration": "A mérkőzés hossza",
"tooltip_first_blood_time": "Első Vérontás ideje",
"tooltip_kda": "(Ölések + Segítség) / (Halálok + 1)",
"tooltip_stuns": "Bénított másodpercek hősökön",
"tooltip_dead": "Halottként töltött idő",
"tooltip_buybacks": "Visszavételek száma",
"tooltip_camps_stacked": "Halmozott táborok",
"tooltip_tower_kills": "Lerombolt tornyok száma",
"tooltip_neutral_kills": "Megölt semleges creepek száma",
"tooltip_courier_kills": "Megölt futárok száma",
"tooltip_purchase_tpscroll": "Teleport vásárlások száma",
"tooltip_purchase_ward_observer": "Figyelő Ward vásárlások",
"tooltip_purchase_ward_sentry": "Őrző Ward cásárlások",
"tooltip_purchase_smoke_of_deceit": "Füst vásárlások",
"tooltip_purchase_dust": "Por vásárlások",
"tooltip_purchase_gem": "Drágakő vásárlások",
"tooltip_purchase_rapier": "Divine Rapier vásárlások",
"tooltip_purchase_buyback": "Visszavétel vásárlások",
"tooltip_duration_observer": "Figyelő wardok átlagos élettartama",
"tooltip_duration_sentry": "Őrző Wardok átlagos élettartama",
"tooltip_used_ward_observer": "Elhelyezett Figyelő Wardok száma a mérkőzés alatt",
"tooltip_used_ward_sentry": "Elhelyezett Őrző Wardok száma a mérkőzés alatt",
"tooltip_used_dust": "Por használatainak száma a mérkőzés alatt",
"tooltip_used_smoke_of_deceit": "Füst használatainak száma a mérkőzés alatt",
"tooltip_parsed": "A visszajátszás elemezve lett további adatokért",
"tooltip_unparsed": "A visszajátszás még nincs elemezve. Adatok hiányozhatnak.",
"tooltip_hero_id": "Játszott hős",
"tooltip_result": "A játékos akár nyert, akár vesztett",
"tooltip_match_id": "A mérkőzés azonosítója",
"tooltip_game_mode": "A mérkőzés módja",
"tooltip_skill": "Számított MMR határok a szintek között 0, 3200 és 3700",
"tooltip_ended": "A mérkőzés végének időpontja",
"tooltip_pick_order": "A játékososk választási sorrendje",
"tooltip_throw": "Legnagyobb arany előny egy elvesztett mérkőzésen",
"tooltip_comeback": "Legnagyobb arany hátrány egy megnyert mérkőzésen",
"tooltip_stomp": "Legnagyobb arany előny egy megnyert mérkőzésen",
"tooltip_loss": "Legnagyobb arany hátrány egy elvesztett mérkőzésen",
"tooltip_items": "Tárgyak összerakva",
"tooltip_permanent_buffs": "Maradandó erősítők, mint a Flesh Heap pontok vagy elhasznált Tudás Könyve",
"tooltip_lane": "Megállapított vonal a korai játékbeli pozició alapján",
"tooltip_map": "Játékososk hőtérképe a korai játékbeli pozicióból",
"tooltip_lane_efficiency": "Megszerzett arany a vonalról (creepek+passzív+kezdő) 10 perc leforgása alatt",
"tooltip_lane_efficiency_pct": "Százalékosan megszerzett arany a vonalról (creepek+passzív+kezdő) 10 perc leforgása alatt",
"tooltip_pings": "Térképen való pingelések száma a játékos által",
"tooltip_DOTA_UNIT_ORDER_MOVE_TO_POSITION": "Játékos pozícióra való mozgásának száma",
"tooltip_DOTA_UNIT_ORDER_MOVE_TO_TARGET": "Játékos célpontra való mozgásainak száma",
"tooltip_DOTA_UNIT_ORDER_ATTACK_MOVE": "Játékos által megtámadott pozíciók száma (auto-támadás)",
"tooltip_DOTA_UNIT_ORDER_ATTACK_TARGET": "Játékos által megtámadott célpontok száma",
"tooltip_DOTA_UNIT_ORDER_CAST_POSITION": "Játékos pozíción való tárgy- vagy képességhasználatainak száma",
"tooltip_DOTA_UNIT_ORDER_CAST_TARGET": "Játékos célponton való tárgy- vagy képességhasználatainak száma",
"tooltip_DOTA_UNIT_ORDER_CAST_NO_TARGET": "Játékos cél vagy pozíció nélküli tárgy- vagy képességhasználatainak száma",
"tooltip_DOTA_UNIT_ORDER_HOLD_POSITION": "Játékos helyben maradásainak száma",
"tooltip_DOTA_UNIT_ORDER_GLYPH": "Játékos által aktivált Védelmek száma",
"tooltip_DOTA_UNIT_ORDER_RADAR": "Játékos által aktivált Szkennelések száma",
"tooltip_last_played": "Az utolsó időpont amikor ez a játékos ezt a hőst választotta egy mérkőzésen",
"tooltip_matches": "Mérkőzések a játékos oldalán vagy ellene",
"tooltip_played_as": "Ezzel a hőssel játszott mérkőzések száma",
"tooltip_played_with": "Mérkőzések száma ahol ez a játékos ezzel a hőssel játszott szövetségesként",
"tooltip_played_against": "Mérkőzések száma ahol ez a játékos ezzel a hőssel játszott ellenfélként",
"tooltip_tombstone_victim": "Itt Nyugszik",
"tooltip_tombstone_killer": "megölte",
"tooltip_win_pct_as": "Győzelmiarány ezzel a hőssel",
"tooltip_win_pct_with": "Győzelmi arány ezzel a játékossal és hőssel szövetségesként",
"tooltip_win_pct_against": "Győzelmi arány ezzel a játékossal és hőssel ellenfélként",
"tooltip_lhten": "Utolsó találatok 10 perc alatt",
"tooltip_dnten": "Beáldozások 10 perc alatt",
"tooltip_biggest_hit": "Hősön okozott legnagyobb sebzés",
"tooltip_damage_dealt": "Képesség vagy tárgy által hősön okozott sebzés",
"tooltip_damage_received": "Képesség vagy tárgy által kapott sebzés",
"tooltip_registered_user": "Regisztrált felhasználó",
"tooltip_ability_builds": "Képességek",
"tooltip_ability_builds_expired": "Ezen mérkőzés képesség fejlesztési adatai elavultak. Használd a kérelmezési űrlapot az adatokért.",
"tooltip_multikill": "Leghosszabb többszörös ölés",
"tooltip_killstreak": "Leghosszabb ölés sorozat",
"tooltip_casts": "Képesség vagy tárgy használatainak száma",
"tooltip_target_abilities": "Hányszor volt egy hős célpontja ennek a képességnek",
"tooltip_hits": "Ezen képesség által okozott sebzések száma",
"tooltip_damage": "Sebzés mértéke amit az a tárgy vagy képesség okozott ",
"tooltip_autoattack_other": "Auto-Támadás/Egyéb",
"tooltip_estimated_mmr": "MMR számítás a felhasználó elmúlt meccseinek átlagos MMR értékei alapján",
"tooltip_backpack": "Hátizsák",
"tooltip_others_tracked_deaths": "nyomkövetett halálok",
"tooltip_others_track_gold": "arany megszerezve Nyomkövetésből",
"tooltip_others_greevils_gold": "arany megszerezve Greevil Kapzsiságából",
"tooltip_advantage": "Wilson pontok alapján számítva",
"tooltip_winrate_samplesize": "Győzelmi arány és minta méret",
"tooltip_teamfight_participation": "Csapatharcban való részvétel mértéke",
"histograms_name": "Hisztogramok",
"histograms_description": "A százalékok mutatják a kiválasztott oszlop nyerési arányait",
"histograms_actions_per_min_description": "Játékos percenkénti cselekvései",
"histograms_comeback_description": "Legnagyobb arany hátrány egy nyertes játékban",
"histograms_lane_efficiency_pct_description": "Százalékos vonalon szerzett arany (creepek+passzív+kezdő) az első 10 percben",
"histograms_gold_per_min_description": "Percenként farmolt arany",
"histograms_hero_damage_description": "Hősökre mért sebzés mértéke",
"histograms_hero_healing_description": "Hősök gyógyításának mértéke",
"histograms_level_description": "Játékban elért szint",
"histograms_loss_description": "Legnagyobb arany hátrány egy nyertes játékban",
"histograms_pings_description": "Játékos általi pingek a térképen",
"histograms_stomp_description": "Legnagyobb arany előny egy nyertes játékban",
"histograms_stuns_description": "Bnítás másodpercekben egy mérkőzésen",
"histograms_throw_description": "Legnagyobb arany előny egy vesztes játékban",
"histograms_purchase_tpscroll_description": "Vásárolt teleportok",
"histograms_xp_per_min_description": "Percenkénti szerzett tapasztalat",
"trends_name": "Trendek",
"trends_description": "Az elmúlt 500 játék összesített átlaga",
"trends_tooltip_average": "Átl.",
"trends_no_data": "Elnézést, nem áll rendelkezésre információ ehez a grafikonhoz",
"xp_reasons_0": "Egyéb",
"xp_reasons_1": "Hős",
"xp_reasons_2": "Creep",
"xp_reasons_3": "Roshan",
"rankings_description": "",
"rankings_none": "Ez a játékos nincs osztályozva egy hőssel sem.",
"region_0": "Automatikus",
"region_1": "Nyugat-USA",
"region_2": "Kelet-USA",
"region_3": "Luxemburg",
"region_5": "Szingapúr",
"region_6": "Dubaj",
"region_7": "Ausztrália",
"region_8": "Stockholm",
"region_9": "Ausztria",
"region_10": "Brazília",
"region_11": "Dél-Afrika",
"region_12": "Kína Telecom Sanghaj",
"region_13": "Kína Unicom",
"region_14": "Csíle",
"region_15": "Peru",
"region_16": "India",
"region_17": "Kína Telecom Kuangtung",
"region_18": "Kína Telecom Csöcsiang",
"region_19": "Japán",
"region_20": "Kína Telecom Wuhan",
"region_25": "Kína Unicom 2",
"vision_expired": "Lejárt ezután",
"vision_destroyed": "Elpusztítva ezután",
"vision_all_time": "Mindenkori",
"vision_placed_observer": "elhelyezett egy Figyelőt ekkor",
"vision_placed_sentry": "elhelyezett egy Őrszemet ekkor",
"vision_ward_log": "Ward Jegyzőkönyv",
"chat_category_faction": "Oldal",
"chat_category_type": "Típus",
"chat_category_target": "Célpont",
"chat_category_other": "Egyéb",
"chat_filter_text": "Szöveg",
"chat_filter_phrases": "Szólás",
"chat_filter_audio": "Hang",
"chat_filter_spam": "Spam",
"chat_filter_all": "Összes",
"chat_filter_allies": "Szövetségesek",
"chat_filter_spectator": "Néző",
"chat_filtered": "Szűrt",
"advb_almost": "majdnem",
"advb_over": "túl",
"advb_about": "csaknem",
"article_before_consonant_sound": "a",
"article_before_vowel_sound": "az",
"statement_long": "jelentette ki",
"statement_shouted": "kiáltotta",
"statement_excited": "kiáltotta",
"statement_normal": "mondta",
"statement_laughed": "nevetett",
"question_long": "emelte fel hangját válaszokat várva",
"question_shouted": "kérdezte",
"question_excited": "vallatta",
"question_normal": "kérdezte",
"question_laughed": "nevetett gúnyossan",
"statement_response_long": "tanácsolta",
"statement_response_shouted": "válaszolt zavartan",
"statement_response_excited": "kiáltott fel",
"statement_response_normal": "válaszolt",
"statement_response_laughed": "nevetett",
"statement_continued_long": "óbégatott",
"statement_continued_shouted": "folytatta dühössen",
"statement_continued_excited": "folytatta",
"statement_continued_normal": "fűzte hozzá",
"statement_continued_laughed": "folytatta",
"question_response_long": "tanácsolta",
"question_response_shouted": "kérdezett vissza magabiztosan",
"question_response_excited": "vitatta",
"question_response_normal": "vágott vissza",
"question_response_laughed": "nevetett",
"question_continued_long": "hozakodott elő vele",
"question_continued_shouted": "kérdezte dühöngve",
"question_continued_excited": "kérdezte édeskedve",
"question_continued_normal": "kérdezte",
"question_continued_laughed": "kérdezte mókásan",
"hero_disclaimer_pro": "Professzionális mérkőzések adatai",
"hero_disclaimer_public": "Publikus mérkőzések adatai",
"hero_duration_x_axis": "Percek",
"top_tower": "Felső Torony",
"bot_tower": "Alsó Torony",
"mid_tower": "Középső Torony",
"top_rax": "Felső Barakkok",
"bot_rax": "Középső Barakkok",
"mid_rax": "Alsó Barakkok",
"tier1": "1. Szint",
"tier2": "2. Szint",
"tier3": "3. Szint",
"tier4": "4. Szint",
"show_consumables_items": "Fogyaszthatók mutatása",
"activated": "aktiválva",
"rune": "rúna",
"placement": "Elhelyezkedés",
"exclude_turbo_matches": "Turbó mérkőzések kizárása",
"scenarios_subtitle": "Fedezd fel a nyerési esélyeit a mérkőzésbeli tényezők kombinációjának.",
"scenarios_info": "Az elmúlt {0} hét begyűjtött mérkőzés adatai",
"scenarios_item_timings": "Tárgy Időzítések",
"scenarios_misc": "Egyéb",
"scenarios_time": "Idő",
"scenarios_item": "Tárgy",
"scenarios_game_duration": "Játék Időtartam",
"scenarios_scenario": "Forgatókönyvek",
"scenarios_first_blood": "Csapat általi Első Vérontás",
"scenarios_courier_kill": "Csapat levadászta az ellenfél futárját a 3. perc előtt",
"scenarios_pos_chat_1min": "Csapat pozitívan szólt hozzá a mérkőzéshez az első 1 percben",
"scenarios_neg_chat_1min": "Csapat negatívan szólt hozzá a mérkőzéshez az első 1 percben",
"gosu_default": "Testreszabott tanácsok",
"gosu_benchmarks": "Ismerd meg részletesen a hőseid, vonal játékod és szerepeid",
"gosu_performances": "Get your map control performance",
"gosu_laning": "Get why you missed last hits",
"gosu_combat": "Get why kills attempts were unsuccessful",
"gosu_farm": "Get why you missed last hits",
"gosu_vision": "Get how many heroes were killed under your wards",
"gosu_actions": "Get your lost time from mouse usage vs hotkeys",
"gosu_teamfights": "Get who to target during teamfights",
"gosu_analysis": "Get your real MMR bracket",
"back2Top": "Vissza a tetejére",
"activity_subtitle": "Kattints egy napra a részletes információkért",
"vs": "vs.",
"add_team": "Hozzáadás {0} csapathoz",
"team": "Csapat {0}",
"combos": "Kombók",
"combos_title": "Hős Kombinációk",
"combos_description": "Keress hős kombinációkat publikus és profi mérkőzéseken",
"public_matches": "Publikus Mérkőzések",
"pro_matches": "Profi Mérkőzések"
}
| odota/web/src/lang/hu-HU.json/0 | {
"file_path": "odota/web/src/lang/hu-HU.json",
"repo_id": "odota",
"token_count": 24953
} | 276 |
{
"yes": "ใช่",
"no": "ไม่",
"abbr_thousand": "k",
"abbr_million": "m",
"abbr_billion": "b",
"abbr_trillion": "t",
"abbr_quadrillion": "q",
"abbr_not_available": "ไม่มี",
"abbr_pick": "เลือก",
"abbr_win": "ชนะ",
"abbr_number": "ลำดับ",
"analysis_eff": "ประสิทธิภาพในเลน",
"analysis_farm_drought": "GPM ต่ำสุดในช่วงรอบ 5 นาที",
"analysis_skillshot": "สกิลเข้าเป้า",
"analysis_late_courier": "ดีเลย์การอัปเกรด Courier",
"analysis_wards": "ปัก Ward",
"analysis_roshan": "สังหาร Roshan",
"analysis_rune_control": "เก็บรูน",
"analysis_unused_item": "ไอเท็มที่ไม่ได้กดใช้",
"analysis_expected": "ของ",
"announce_dismiss": "ปิด",
"announce_github_more": "ดูบน GitHub",
"api_meta_description": "OpenDota API ช่วยให้คุณเข้าถึงสถิติขั้นสูงทั้งหมดของ Dota 2 ที่นำเสนอโดยแพลตฟอร์ม OpenDota เข้าถึงกราฟประสิทธิภาพ แผนที่ฮีตแมป กลุ่มคำ และอื่น ๆ เริ่มต้นใช้งานได้ฟรี",
"api_title": "OpenDota API",
"api_subtitle": "สร้างบนแพลตฟอร์ม OpenDota นำสถิติขั้นสูงมาสู่แอปของคุณ และให้ข้อมูลเชิงลึกแก่ผู้ใช้ของคุณ",
"api_details_free_tier": "แผนฟรี",
"api_details_premium_tier": "แผนพรีเมี่ยม",
"api_details_price": "ราคา",
"api_details_price_free": "ฟรี",
"api_details_price_prem": "$price ต่อการเรียกใช้ $unit ครั้ง",
"api_details_key_required": "ต้องใช้คีย์ไหม?",
"api_details_key_required_free": "ไม่",
"api_details_key_required_prem": "ใช่ -- จำเป็นต้องมีช่องทางการชำระเงิน",
"api_details_call_limit": "จำกัดการเรียกใช้",
"api_details_call_limit_free": "$limit ต่อเดือน",
"api_details_call_limit_prem": "ไม่จำกัด",
"api_details_rate_limit": "จำกัดอัตราการเรียกใช้",
"api_details_rate_limit_val": "$num การเรียกใช้ต่อนาที",
"api_details_support": "การสนับสนุน",
"api_details_support_free": "การสนับสนุนจากชุมชนผ่านทางกลุ่ม Discord",
"api_details_support_prem": "สิทธิพิเศษในการรับการสนับสนุนจากทีมผู้พัฒนาหลัก",
"api_get_key": "รับคีย์ของฉัน",
"api_docs": "อ่านคู่มือ",
"api_header_details": "รายละเอียด",
"api_charging": "คุณจะถูกเรียกเก็บเงิน $cost ต่อการเรียกใช้ โดยจะปัดเศษเป็นจำนวนที่ใกล้เคียงหลักสิบที่สุด",
"api_credit_required": "การรับคีย์ API จำเป็นต้องมีช่องทางการชำระเงิน เราจะเรียกเก็บเงินจากบัตรโดยอัตโนมัติทุกต้นเดือนตามยอดที่ติดค้างไว้",
"api_failure": "ข้อผิดพลาด 500 ไม่นับเป็นการใช้งาน เนื่องจากเป็นความผิดของเรา",
"api_error": "มีข้อผิดพลาดในการร้องขอ โปรดลองใหม่อีกครั้ง หากยังเหมือนเดิม สามารถติดต่อเราได้ที่ support@opendota.com",
"api_login": "เข้าสู่ระบบเพื่อเข้าถึงคีย์ API",
"api_update_billing": "อัปเดตช่องทางการชำระเงิน",
"api_delete": "ลบคีย์",
"api_key_usage": "ในการใช้งานคีย์ของคุณ ให้เพิ่ม $param เป็นพารามิเตอร์สืบค้นไปยังการร้องขอ API ของคุณ",
"api_billing_cycle": "การเรียกเก็บเงินรอบปัจจุบันจะสิ้นสุดในวันที่ $date",
"api_billed_to": "เราจะเรียกเก็บเงินโดยอัตโนมัติจากบัตร $brand ลงท้ายด้วย $last4",
"api_support": "ต้องการการสนับสนุน? ส่งอีเมลมาที่ $email",
"api_header_usage": "การใช้งานของคุณ",
"api_usage_calls": "# เรียกใช้ API",
"api_usage_fees": "ประเมินค่าธรรมเนียม",
"api_month": "เดือน",
"api_header_key": "คีย์ของคุณ",
"api_header_table": "เริ่มต้นฟรี แล้วทำต่อไปด้วยราคาถูกอย่างเหลือเชื่อ",
"app_name": "OpenDota",
"app_language": "ภาษา",
"app_localization": "การแปล",
"app_description": "แพลตฟอร์มข้อมูล Dota 2 โอเพนซอร์ซ",
"app_about": "เกี่ยวกับเรา",
"app_privacy_terms": "นโยบายและข้อตกลง",
"app_api_docs": "คู่มือ API",
"app_blog": "บล็อก",
"app_translate": "แปล",
"app_donate": "บริจาค",
"app_netlify": "ติดตั้งโดย Netlify",
"app_openunderlords": "OpenUnderlords - สถิติ Dota Underlords",
"app_gravitech": "เว็บไซต์ของ Gravitech LLC",
"app_powered_by": "ขับเคลื่อนโดย",
"app_donation_goal": "เป้าหมายการบริจาคต่อเดือน",
"app_sponsorship": "การสนับสนุนของคุณช่วยทำให้บริการนี้ฟรีสำหรับทุกคน",
"app_twitter": "ติดตามใน Twitter",
"app_github": "ซอร์ซบน GitHub",
"app_discord": "พูดคุยบน Discord",
"app_steam_profile": "โปรไฟล์ Steam",
"app_confirmed_as": "ยืนยันแล้วว่าเป็น",
"app_untracked": "ผู้ใช้รายนี้ไม่ได้เข้าเยี่ยมชมเมื่อเร็ว ๆ นี้ และการแข่งขันนัดใหม่จะไม่ถูกวิเคราะห์โดยอัตโนมัติ",
"app_tracked": "ผู้ใช้รายนี้ได้เข้าเยี่ยมชมเมื่อเร็ว ๆ นี้ และการแข่งขันนัดใหม่จะถูกวิเคราะห์โดยอัตโนมัติ",
"app_cheese_bought": "ซื้อชีส",
"app_contributor": "ผู้ใช้งานรายนี้มีส่วนร่วมในการพัฒนาโครงการ OpenDota",
"app_dotacoach": "ขอคำแนะนำจากโค้ช",
"app_pvgna": "ค้นหาคู่มือ",
"app_pvgna_alt": "ค้นหาคู่มือ Dota 2 บน Pvgna",
"app_rivalry": "เดิมพันแมตช์ระดับมืออาชีพด้วย Rivalry",
"app_rivalry_team": "เดิมพัน {0} แมตช์ระดับมืออาชีพด้วย Rivalry",
"app_refresh": "รีเฟรชประวัติแมตช์ : เข้าคิวสแกนเพื่อค้นหาแมตช์ที่หายไปเนื่องจากการตั้งค่าความเป็นส่วนตัว",
"app_refresh_label": "รีเฟรช",
"app_show_turbo_stats": "Turbo",
"app_login": "เข้าสู่ระบบ",
"app_logout": "ออกจากระบบ",
"app_results": "ผลลัพธ์",
"app_report_bug": "แจ้งบั๊ก",
"app_pro_players": "ผู้เล่นมืออาชีพ",
"app_public_players": "ผู้เล่นสาธารณะ",
"app_my_profile": "โปรไฟล์",
"barracks_value_1": "Dire ล่างระยะประชิด",
"barracks_value_2": "Dire ล่างระยะไกล",
"barracks_value_4": "Dire กลางระยะประชิด",
"barracks_value_8": "Dire กลางระยะไกล",
"barracks_value_16": "Dire บนระยะประชิด",
"barracks_value_32": "Dire บนระยะไกล",
"barracks_value_64": "Radiant ล่างระยะประชิด",
"barracks_value_128": "Radiant ล่างระยะไกล",
"barracks_value_256": "Radiant กลางระยะประชิด",
"barracks_value_512": "Radiant กลางระยะไกล",
"barracks_value_1024": "Radiant บนระยะประชิด",
"barracks_value_2048": "Radiant บนระยะไกล",
"benchmarks_description": "{0} {1} เท่ากับหรือสูงกว่า {2}% ของประสิทธิภาพล่าสุดด้วยฮีโร่ตัวนี้",
"fantasy_description": "{0} ได้ {1} แต้ม",
"building_melee_rax": "บาร์แร็กระยะประชิด",
"building_range_rax": "บาร์แร็กระยะไกล",
"building_lasthit": "ได้ Last Hit",
"building_damage": "ได้รับความเสียหาย",
"building_hint": "สัญลักษณ์บนแผนที่จะมีคำแนะนำ",
"building_denied": "ทำลาย",
"building_ancient": "Ancient",
"CHAT_MESSAGE_TOWER_KILL": "ป้อม",
"CHAT_MESSAGE_BARRACKS_KILL": "บาร์แร็ก",
"CHAT_MESSAGE_ROSHAN_KILL": "Roshan",
"CHAT_MESSAGE_AEGIS": "เก็บ Aegis",
"CHAT_MESSAGE_FIRSTBLOOD": "First Blood",
"CHAT_MESSAGE_TOWER_DENY": "สละป้อม",
"CHAT_MESSAGE_AEGIS_STOLEN": "ขโมย Aegis",
"CHAT_MESSAGE_DENIED_AEGIS": "ทำลาย Aegis",
"cs_over_time": "จำนวนครีปแบ่งตามเวลา",
"cs_this_minute": "จำนวนครีปในนาทีนี้",
"cumulative_cs": "ยอดรวมจำนวนครีป",
"distributions_heading_ranks": "การกระจายของอันดับ",
"distributions_heading_mmr": "การกระจายของ MMR เดี่ยว",
"distributions_heading_country_mmr": "ค่าเฉลี่ย MMR เดี่ยวแบ่งตามประเทศ",
"distributions_tab_ranks": "ระดับอันดับ",
"distributions_tab_mmr": "MMR เดี่ยว",
"distributions_tab_country_mmr": "MMR เดี่ยวแบ่งตามประเทศ",
"distributions_warning_1": "ชุดข้อมูลนี้จำกัดเฉพาะผู้เล่นที่แสดง MMR ในโปรไฟล์ และแบ่งปันข้อมูลแมตช์สาธารณะ",
"distributions_warning_2": "ผู้เล่นไม่จำเป็นต้องลงชื่อเข้าใช้ แต่เนื่องจากลักษณะการเลือกข้อมูลที่รวบรวม ค่าเฉลี่ยจะมีแนวโน้มสูงกว่าที่คาดคิด",
"error": "ข้อผิดพลาด",
"error_message": "อุ๊ย! มีบางอย่างผิดพลาด",
"error_four_oh_four_message": "ไม่พบหน้าเว็บที่คุณต้องการ",
"explorer_title": "โปรแกรมสำรวจข้อมูล",
"explorer_subtitle": "สถิติ Dota 2 ระดับมืออาชีพ",
"explorer_description": "ค้นหาขั้นสูงในแมตช์การแข่งขันระดับมืออาชีพ (ไม่รวมลีกสมัครเล่น)",
"explorer_schema": "เค้าร่าง",
"explorer_results": "ผลการค้นหา",
"explorer_num_rows": "แถว",
"explorer_select": "เลือก",
"explorer_group_by": "จัดกลุ่มโดย",
"explorer_hero": "ฮีโร่",
"explorer_patch": "แพตช์",
"explorer_min_patch": "แพตช์ต่ำสุด",
"explorer_max_patch": "แพตช์สูงสุด",
"explorer_min_mmr": "MMR ต่ำสุด",
"explorer_max_mmr": "MMR สูงสุด",
"explorer_min_rank_tier": "ระดับต่ำสุด",
"explorer_max_rank_tier": "ระดับสูงสุด",
"explorer_player": "ผู้เล่น",
"explorer_league": "ลีก",
"explorer_player_purchased": "ผู้เล่นได้ซื้อ",
"explorer_duration": "ระยะเวลา",
"explorer_min_duration": "ระยะเวลาต่ำสุด",
"explorer_max_duration": "ระยะเวลาสูงสุด",
"explorer_timing": "ช่วงเวลา",
"explorer_uses": "ใช้",
"explorer_kill": "เวลาสังหาร",
"explorer_side": "ฝ่าย",
"explorer_toggle_sql": "สลับโหมด SQL",
"explorer_team": "ทีมปัจจุบัน",
"explorer_lane_role": "เลน",
"explorer_min_date": "วันที่เริ่มต้น",
"explorer_max_date": "วันที่มากสุด",
"explorer_hero_combos": "ฮีโร่ - ฮีโร่",
"explorer_hero_player": "ฮีโร่ - ผู้เล่น",
"explorer_player_player": "ผู้เล่น - ผู้เล่น",
"explorer_sql": "SQL",
"explorer_postgresql_function": "ฟังก์ชัน PostgreSQL",
"explorer_table": "ตาราง",
"explorer_column": "คอลัมน์",
"explorer_query_button": "สืบค้น",
"explorer_cancel_button": "ยกเลิก",
"explorer_table_button": "ตาราง",
"explorer_api_button": "API",
"explorer_json_button": "JSON",
"explorer_csv_button": "CSV ",
"explorer_donut_button": "แผนภูมิโดนัท",
"explorer_bar_button": "แผนภูมิแท่ง",
"explorer_timeseries_button": "อนุกรมเวลา",
"explorer_chart_unavailable": "ชาร์ตไม่พร้อมใช้ โปรดลองเพิ่ม 'จัดกลุ่มโดย'",
"explorer_value": "ค่า",
"explorer_category": "หมวดหมู่",
"explorer_region": "ภูมิภาค",
"explorer_picks_bans": "เลือก/แบน",
"explorer_counter_picks_bans": "เลือก/แบนแก้ทาง",
"explorer_organization": "องค์กร",
"explorer_order": "ลำดับ",
"explorer_asc": "จากน้อยไปมาก",
"explorer_desc": "จากมากไปน้อย",
"explorer_tier": "ระดับชั้น",
"explorer_having": "จำนวนแมตช์อย่างน้อย",
"explorer_limit": "จำกัด",
"explorer_match": "แมตช์",
"explorer_is_ti_team": "เป็นทีม TI{number}",
"explorer_mega_comeback": "พลิกเกมหลังจากเมก้าครีป",
"explorer_max_gold_adv": "ได้เปรียบจำนวนโกลด์สูงสุด",
"explorer_min_gold_adv": "ได้เปรียบจำนวนโกลด์ต่ำสุด",
"farm_heroes": "สังหารฮีโร่",
"farm_creeps": "สังหารครีปเลน",
"farm_neutrals": "สังหารครีปป่า (รวมครีป Ancient)",
"farm_ancients": "สังหารครีป Ancient",
"farm_towers": "ทำลาย Tower",
"farm_couriers": "สังหาร Courier",
"farm_observers": "ทำลาย Ward",
"farm_sentries": "ทำลาย Sentry",
"farm_roshan": "สังหาร Roshan",
"farm_necronomicon": "สังหารยูนิต Necronomicon",
"filter_button_text_open": "ตัวกรอง",
"filter_button_text_close": "ปิด",
"filter_hero_id": "ฮีโร่",
"filter_is_radiant": "ฝ่าย",
"filter_win": "ผลลัพธ์",
"filter_lane_role": "เลน",
"filter_patch": "แพตช์",
"filter_game_mode": "โหมดเกม",
"filter_lobby_type": "ประเภทล็อบบี้",
"filter_date": "วันที่",
"filter_region": "ภูมิภาค",
"filter_with_hero_id": "ฮีโร่ฝ่ายเดียวกัน",
"filter_against_hero_id": "ฮีโร่ฝ่ายศัตรู",
"filter_included_account_id": "รวมบัญชี ID",
"filter_excluded_account_id": "ยกเว้นบัญชี ID",
"filter_significant": "ไม่สำคัญ",
"filter_significant_include": "รวม",
"filter_last_week": "สัปดาห์ที่แล้ว",
"filter_last_month": "เดือนที่แล้ว",
"filter_last_3_months": "3 เดือนล่าสุด",
"filter_last_6_months": "6 เดือนล่าสุด",
"filter_last_12_months": "12 เดือนล่าสุด",
"filter_error": "โปรดเลือกไอเท็มจากรายการ",
"filter_party_size": "ขนาดปาร์ตี้",
"game_mode_0": "ไม่ทราบ",
"game_mode_1": "All Pick",
"game_mode_2": "Captains Mode",
"game_mode_3": "Random Draft",
"game_mode_4": "Single Draft",
"game_mode_5": "All Random",
"game_mode_6": "บทนำ",
"game_mode_7": "Diretide",
"game_mode_8": "Reverse Captains Mode",
"game_mode_9": "The Greeviling",
"game_mode_10": "แบบฝึกสอน",
"game_mode_11": "Mid Only",
"game_mode_12": "Least Played",
"game_mode_13": "Limited Heroes",
"game_mode_14": "Compendium",
"game_mode_15": "แบบกำหนดเอง",
"game_mode_16": "Captains Draft",
"game_mode_17": "Balanced Draft",
"game_mode_18": "โหมดสุ่มความสามารถ",
"game_mode_19": "กิจกรรม",
"game_mode_20": "All Random Deathmatch",
"game_mode_21": "1v1 Solo Mid",
"game_mode_22": "All Draft",
"game_mode_23": "Turbo",
"game_mode_24": "Mutation",
"general_unknown": "ไม่ทราบ",
"general_no_hero": "ไม่มีฮีโร่",
"general_anonymous": "ไม่ระบุชื่อ",
"general_radiant": "Radiant",
"general_dire": "Dire",
"general_standard_deviation": "ค่าเบี่ยงเบนมาตรฐาน",
"general_matches": "แมตช์",
"general_league": "ลีก",
"general_randomed": "สุ่ม",
"general_repicked": "เลือกใหม่",
"general_predicted_victory": "ทำนายผลชนะ",
"general_show": "แสดง",
"general_hide": "ซ่อน",
"gold_reasons_0": "อื่น ๆ",
"gold_reasons_1": "ตาย",
"gold_reasons_2": "ซื้อเกิด",
"NULL_gold_reasons_5": "ละทิ้ง",
"NULL_gold_reasons_6": "ขาย",
"gold_reasons_11": "สิ่งก่อสร้าง",
"gold_reasons_12": "ฮีโร่",
"gold_reasons_13": "ครีป",
"gold_reasons_14": "ครีปป่า",
"gold_reasons_15": "Roshan",
"NULL_gold_reasons_16": "Courier",
"gold_reasons_17": "รูน",
"gold_reasons_20": "Ward",
"header_request": "ร้องขอ",
"header_distributions": "การกระจาย",
"header_heroes": "ฮีโร่",
"header_blog": "บล็อก",
"header_ingame": "ในเกม",
"header_matches": "แมตช์",
"header_records": "สถิติ",
"header_explorer": "สำรวจ",
"header_teams": "ทีม",
"header_meta": "เมต้า",
"header_scenarios": "สถานการณ์",
"header_api": "API",
"heading_lhten": "Last Hit ที่ 10 นาที",
"heading_lhtwenty": "Last Hit ที่ 20 นาที",
"heading_lhthirty": "Last Hit ที่ 30 นาที",
"heading_lhforty": "Last Hit ที่ 40 นาที",
"heading_lhfifty": "Last Hit ที่ 50 นาที",
"heading_courier": "Courier",
"heading_roshan": "Roshan",
"heading_tower": "ป้อม",
"heading_barracks": "บาร์แร็ก",
"heading_shrine": "Shrine",
"heading_item_purchased": "ไอเท็มที่ซื้อ",
"heading_ability_used": "สกิลที่ใช้",
"heading_item_used": "ไอเท็มที่ใช้",
"heading_damage_inflictor": "ความเสียหายที่สร้าง",
"heading_damage_inflictor_received": "ความเสียหายที่ได้รับ",
"heading_damage_instances": "จำนวนครั้งความเสียหาย",
"heading_camps_stacked": "จำนวนแคมป์ที่ลากครีป",
"heading_matches": "แมตช์ล่าสุด",
"heading_heroes": "ฮีโร่ที่เคยเล่น",
"heading_mmr": "ประวัติ MMR",
"heading_peers": "ผู้เล่นที่เคยเล่นด้วย",
"heading_pros": "ผู้เล่นระดับมืออาชีพที่เคยเล่นด้วย",
"heading_rankings": "อันดับฮีโร่",
"heading_all_matches": "ในแมตช์ทั้งหมด",
"heading_parsed_matches": "ในแมตช์ที่วิเคราะห์แล้ว",
"heading_records": "สถิติ",
"heading_teamfights": "การต่อสู้เป็นทีม",
"heading_graph_difference": "ความได้เปรียบของฝ่าย Radiant",
"heading_graph_gold": "โกลด์",
"heading_graph_xp": "ค่าประสบการณ์",
"heading_graph_lh": "Last Hit",
"heading_graph_cs": "Last Hit + Deny",
"heading_overview": "ภาพรวม",
"heading_ability_draft": "สกิลที่เลือก",
"heading_buildings": "แผนที่สิ่งก่อสร้าง",
"heading_benchmarks": "การเทียบสมรรถนะ",
"heading_laning": "ช่วงในเลน",
"heading_overall": "รวมทั้งหมด",
"heading_kills": "สังหาร",
"heading_deaths": "ตาย",
"heading_assists": "ช่วยเหลือ",
"heading_damage": "ความเสียหาย",
"heading_unit_kills": "สังหารยูนิต",
"heading_last_hits": "Last Hit",
"heading_gold_reasons": "ที่มาของโกลด์",
"heading_xp_reasons": "ที่มาของ XP",
"heading_performances": "ประสิทธิภาพ",
"heading_support": "การสนับสนุน",
"heading_purchase_log": "บันทึกการซื้อ",
"heading_casts": "ร่ายสกิล",
"heading_objective_damage": "ความเสียหายต่อเป้าหมายสำคัญ",
"heading_runes": "รูน",
"heading_vision": "วิสัยทัศน์",
"heading_actions": "กดคำสั่ง",
"heading_analysis": "การวิเคราะห์",
"heading_cosmetics": "ไอเท็มตกแต่ง",
"heading_log": "บันทึก",
"heading_chat": "แช็ต",
"heading_story": "เรื่องราว",
"heading_fantasy": "Fantasy",
"heading_wardmap": "แผนที่ Ward",
"heading_wordcloud": "กลุ่มคำ",
"heading_wordcloud_said": "ข้อความที่พิมพ์ (แช็ตทั้งหมด)",
"heading_wordcloud_read": "ข้อความที่อ่าน (แช็ตทั้งหมด)",
"heading_kda": "KLA",
"heading_gold_per_min": "Gold ต่อนาที",
"heading_xp_per_min": "XP ต่อนาที่",
"heading_denies": "Deny",
"heading_lane_efficiency_pct": "EFF@10",
"heading_duration": "ระยะเวลา",
"heading_level": "เลเวล",
"heading_hero_damage": "ความเสียหายต่อฮีโร่",
"heading_tower_damage": "ความเสียหายต่อป้อม",
"heading_hero_healing": "การรักษาฮีโร่",
"heading_tower_kills": "ทำลายป้อม",
"heading_stuns": "สตัน",
"heading_neutral_kills": "สังหารครีปป่า",
"heading_courier_kills": "สังหาร Courier",
"heading_purchase_tpscroll": "ซื้อ Town Portal Scroll",
"heading_purchase_ward_observer": "ซื้อ Observer Ward",
"heading_purchase_ward_sentry": "ซื้อ Sentry Ward",
"heading_purchase_gem": "ซื้อ Gem of True Sight",
"heading_purchase_rapier": "ซื้อ Divine Rapier",
"heading_pings": "ชี้เตือนในแผนที่",
"heading_throw": "โยนเกม",
"heading_comeback": "พลิกเกม",
"heading_stomp": "ถล่มทลาย",
"heading_loss": "สูญเสีย",
"heading_actions_per_min": "กดคำสั่งต่อนาที",
"heading_leaver_status": "สถานะการละทิ้ง",
"heading_game_mode": "โหมดเกม",
"heading_lobby_type": "ประเภทล็อบบี้",
"heading_lane_role": "ตำแหน่งในเลน",
"heading_region": "ภูมิภาค",
"heading_patch": "แพตช์",
"heading_win_rate": "อัตราการชนะ",
"heading_is_radiant": "ฝ่าย",
"heading_avg_and_max": "ค่าเฉลี่ย/สูงสุด",
"heading_total_matches": "แมตช์ทั้งหมด",
"heading_median": "มัธยฐาน",
"heading_distinct_heroes": "ฮีโร่ที่ไม่ซ้ำ",
"heading_team_elo_rankings": "อันดับ Elo ของทีม",
"heading_ability_build": "การอัปสกิล",
"heading_attack": "พลังโจมตีพื้นฐาน",
"heading_attack_range": "ระยะการโจมตี",
"heading_attack_speed": "ความเร็วการโจมตี",
"heading_projectile_speed": "ความเร็วกระสุน",
"heading_base_health": "พลังชีวิต",
"heading_base_health_regen": "อัตราฟื้นฟูพลังชีวิต",
"heading_base_mana": "มานา",
"heading_base_mana_regen": "อัตราฟื้นฟูมานา",
"heading_base_armor": "เกราะป้องกันพื้นฐาน",
"heading_base_mr": "ความต้านทานเวทมนตร์",
"heading_move_speed": "ความเร็วในการเคลื่อนที่",
"heading_turn_rate": "อัตราการหมุนตัว",
"heading_legs": "จำนวนนัดแข่ง",
"heading_cm_enabled": "เปิดใช้งานโหมดกัปตัน",
"heading_current_players": "ผู้เล่นปัจจุบัน",
"heading_former_players": "ผู้เล่นในอดีต",
"heading_damage_dealt": "ความเสียหายที่สร้าง",
"heading_damage_received": "ความเสียหายที่ได้รับ",
"show_details": "แสดงรายละเอียด",
"hide_details": "ซ่อนรายละเอียด",
"subheading_avg_and_max": "ใน {0} แมตช์ล่าสุด",
"subheading_records": "ในแมตช์จัดอันดับ สถิติจะนับใหม่ทุกเดือน",
"subheading_team_elo_rankings": "k=32, init=1000",
"hero_pro_tab": "ระดับมืออาชีพ",
"hero_public_tab": "สาธารณะ",
"hero_turbo_tab": "Turbo",
"hero_pro_heading": "ฮีโร่ในแมตช์ระดับมืออาชีพ",
"hero_public_heading": "ฮีโร่ในแมตช์สาธารณะ (กลุ่มตัวอย่าง)",
"hero_turbo_heading": "ฮีโร่ในแมตช์ Turbo",
"hero_last_30days": "แมตช์ใน 30 วันล่าสุด",
"hero_this_month": "แมตช์ในเดือนนี้",
"hero_pick_ban_rate": "Pro P+B%",
"hero_pick_rate": "Pro Pick%",
"hero_ban_rate": "Pro Ban%",
"hero_win_rate": "Pro Win%",
"hero_turbo_pick_rate": "% เลือก Turbo",
"hero_turbo_win_rate": "% ชนะ Turbo",
"hero_5000_pick_rate": ">5K P%",
"hero_5000_win_rate": ">5K W%",
"hero_4000_pick_rate": "4K P%",
"hero_4000_win_rate": "4K W%",
"hero_3000_pick_rate": "3K P%",
"hero_3000_win_rate": "3K W%",
"hero_2000_pick_rate": "2K P%",
"hero_2000_win_rate": "2K W%",
"hero_1000_pick_rate": "<2K P%",
"hero_1000_win_rate": "<2K W%",
"home_login": "เข้าสู่ระบบ",
"home_login_desc": "สำหรับการวิเคราะห์แมตช์โดยอัตโนมัติ",
"home_parse": "ร้องขอ",
"home_parse_desc": "เจาะจงแมตช์",
"home_why": "",
"home_opensource_title": "โอเพนซอร์ซ",
"home_opensource_desc": "โค้ดในโครงการทั้งหมดเป็นโอเพนซอร์ซและเปิดให้ทุกคนมีส่วนร่วมช่วยปรับปรุงและแก้ไข",
"home_indepth_title": "ข้อมูลเชิงลึก",
"home_indepth_desc": "การวิเคราะห์รีเพลย์ช่วยทำให้ได้ข้อมูลแมตช์โดยละเอียด",
"home_free_title": "ไม่มีค่าใช้จ่าย",
"home_free_desc": "เซิร์ฟเวอร์ได้รับทุนจากผู้สนับสนุนและมีอาสาสมัครช่วยดูแลโค้ด ดังนั้นการใช้บริการนี้จึงไม่มีค่าใช้จ่าย",
"home_background_by": "ภาพพื้นหลังโดย",
"home_sponsored_by": "สนับสนุนโดย",
"home_become_sponsor": "ร่วมเป็นผู้สนับสนุน",
"items_name": "ชื่อไอเท็ม",
"items_built": "จำนวนครั้งที่สร้างไอเท็มนี้",
"items_matches": "จำนวนแมตช์ที่สร้างไอเท็มนี้",
"items_uses": "จำนวนครั้งที่ใช้งานไอเท็มนี้",
"items_uses_per_match": "ค่าเฉลี่ยที่ไอเท็มนี้ถูกใช้งานในแมตช์ที่สร้างไอเท็มนี้",
"items_timing": "ค่าเฉลี่ยเวลาที่สร้างไอเท็มนี้",
"items_build_pct": "เปอร์เซ็นต์ของแมตช์ที่สร้างไอเท็มนี้",
"items_win_pct": "เปอร์เซ็นต์ของแมตช์ที่ชนะเมื่อสร้างไอเท็มนี้",
"lane_role_0": "ไม่ทราบ",
"lane_role_1": "เซฟเลน",
"lane_role_2": "เลนกลาง",
"lane_role_3": "ออฟเลน",
"lane_role_4": "ฟาร์มป่า",
"lane_pos_1": "เลนล่าง",
"lane_pos_2": "เลนกลาง",
"lane_pos_3": "เลนบน",
"lane_pos_4": "ป่า Radiant",
"lane_pos_5": "ป่า Dire",
"leaver_status_0": "ไม่มี",
"leaver_status_1": "ออกเกมอย่างปลอดภัย",
"leaver_status_2": "ละทิ้งเกม (DC)",
"leaver_status_3": "ละทิ้งเกม",
"leaver_status_4": "ละทิ้งเกม (AFK)",
"leaver_status_5": "ไม่ได้เชื่อมต่อ",
"leaver_status_6": "ไม่ได้เชื่อมต่อ (หมดเวลา)",
"lobby_type_0": "ปกติ",
"lobby_type_1": "ฝึกซ้อม",
"lobby_type_2": "ทัวร์นาเมนต์",
"lobby_type_3": "แบบฝึกสอน",
"lobby_type_4": "ร่วมกันสู้กับบอท",
"lobby_type_5": "MMR ทีม (อดีต)",
"lobby_type_6": "MMR เดี่ยว (อดีต)",
"lobby_type_7": "จัดอันดับ",
"lobby_type_8": "1v1 Mid",
"lobby_type_9": "Battle Cup",
"match_radiant_win": "Radiant เป็นฝ่ายชนะ",
"match_dire_win": "Dire เป็นฝ่ายชนะ",
"match_team_win": "ชนะ",
"match_ended": "สิ้นสุด",
"match_id": "ไอดีแมตช์",
"match_region": "ภูมิภาค",
"match_avg_mmr": "MMR โดยเฉลี่ย",
"match_button_parse": "วิเคราะห์",
"match_button_reparse": "วิเคราะห์ใหม่",
"match_button_replay": "รีเพลย์",
"match_button_video": "สร้างวิดีโอ",
"match_first_tower": "ป้อมแรก",
"match_first_barracks": "บาร์แร็กแรก",
"match_pick": "เลือก",
"match_ban": "แบน",
"matches_highest_mmr": "แมตช์สาธารณะระดับสูง",
"matches_lowest_mmr": "MMR ต่ำ",
"meta_title": "เมต้า",
"meta_description": "สืบค้นข้อมูลขั้นสูงจากกลุ่มตัวอย่างแมตช์สาธารณะล่าสุด",
"mmr_not_up_to_date": "ทำไม MMR ถึงไม่อัปเดต?",
"npc_dota_beastmaster_boar_#": "Boar",
"npc_dota_lesser_eidolon": "Lesser Eidolon",
"npc_dota_eidolon": "Eidolon",
"npc_dota_greater_eidolon": "Greater Eidolon",
"npc_dota_dire_eidolon": "Dire Eidolon",
"npc_dota_invoker_forged_spirit": "Forged Spirit",
"npc_dota_furion_treant_large": "Greater Treant",
"npc_dota_beastmaster_hawk_#": "Hawk",
"npc_dota_lycan_wolf#": "Lycan Wolf",
"npc_dota_neutral_mud_golem_split_doom": "Doom Shard",
"npc_dota_broodmother_spiderling": "Spiderling",
"npc_dota_broodmother_spiderite": "Spiderite",
"npc_dota_furion_treant": "Treant",
"npc_dota_unit_undying_zombie": "Undying Zombie",
"npc_dota_unit_undying_zombie_torso": "Undying Zombie",
"npc_dota_brewmaster_earth_#": "Earth Brewling",
"npc_dota_brewmaster_fire_#": "Fire Brewling",
"npc_dota_lone_druid_bear#": "Spirit Bear",
"npc_dota_brewmaster_storm_#": "Storm Brewling",
"npc_dota_visage_familiar#": "Familiar",
"npc_dota_warlock_golem_#": "Warlock Golem",
"npc_dota_warlock_golem_scepter_#": "Warlock Golem",
"npc_dota_witch_doctor_death_ward": "Death Ward",
"npc_dota_tusk_frozen_sigil#": "Frozen Sigil",
"npc_dota_juggernaut_healing_ward": "Healing Ward",
"npc_dota_techies_land_mine": "Proximity Mine",
"npc_dota_shadow_shaman_ward_#": "Serpent Ward",
"npc_dota_pugna_nether_ward_#": "Nether Ward",
"npc_dota_venomancer_plague_ward_#": "Plague Ward",
"npc_dota_rattletrap_cog": "Power Cog",
"npc_dota_templar_assassin_psionic_trap": "Psionic Trap",
"npc_dota_techies_remote_mine": "Remote Mine",
"npc_dota_techies_stasis_trap": "Stasis Trap",
"npc_dota_phoenix_sun": "Supernova",
"npc_dota_unit_tombstone#": "Tombstone",
"npc_dota_treant_eyes": "Eyes in the Forest",
"npc_dota_gyrocopter_homing_missile": "Homing Missile",
"npc_dota_weaver_swarm": "The Swarm",
"objective_tower1_top": "T1",
"objective_tower1_mid": "M1",
"objective_tower1_bot": "B1",
"objective_tower2_top": "T2",
"objective_tower2_mid": "M2",
"objective_tower2_bot": "B2",
"objective_tower3_top": "T3",
"objective_tower3_mid": "M3",
"objective_tower3_bot": "B3",
"objective_rax_top": "RaxT",
"objective_rax_mid": "RaxM",
"objective_rax_bot": "RaxB",
"objective_tower4": "T4",
"objective_fort": "Anc",
"objective_shrine": "Shr",
"objective_roshan": "Rosh",
"tooltip_objective_tower1_top": "ความเสียหายที่สร้างต่อป้อมบนชั้นที่ 1",
"tooltip_objective_tower1_mid": "ความเสียหายที่สร้างต่อป้อมกลางชั้นที่ 1",
"tooltip_objective_tower1_bot": "ความเสียหายที่สร้างต่อป้อมล่างชั้นที่ 1",
"tooltip_objective_tower2_top": "ความเสียหายที่สร้างต่อป้อมบนชั้นที่ 2",
"tooltip_objective_tower2_mid": "ความเสียหายที่สร้างต่อป้อมกลางชั้นที่ 2",
"tooltip_objective_tower2_bot": "ความเสียหายที่สร้างต่อป้อมล่างชั้นที่ 2",
"tooltip_objective_tower3_top": "ความเสียหายที่สร้างต่อป้อมบนชั้นที่ 3",
"tooltip_objective_tower3_mid": "ความเสียหายที่สร้างต่อป้อมกลางชั้นที่ 3",
"tooltip_objective_tower3_bot": "ความเสียหายที่สร้างต่อป้อมล่างชั้นที่ 3",
"tooltip_objective_rax_top": "ความเสียหายที่สร้างต่อบาร์แร็กฝั่งบน",
"tooltip_objective_rax_mid": "ความเสียหายที่สร้างต่อบาร์แร็กกลาง",
"tooltip_objective_rax_bot": "ความเสียหายที่สร้างต่อบาร์แร็กฝั่งล่าง",
"tooltip_objective_tower4": "ความเสียหายที่สร้างต่อป้อมกลางชั้นที่ 4",
"tooltip_objective_fort": "ความเสียหายที่สร้างต่อ Ancient",
"tooltip_objective_shrine": "ความเสียหายที่สร้างต่อ Shrine",
"tooltip_objective_roshan": "ความเสียหายที่สร้างต่อ Roshan",
"pagination_first": "แรก",
"pagination_last": "สุดท้าย",
"pagination_of": "ของ",
"peers_none": "ผู้เล่นนี้ไม่มีผู้ร่วมเล่นประจำ",
"rank_tier_0": "รอปรับเทียบ",
"rank_tier_1": "Herald",
"rank_tier_2": "Guardian",
"rank_tier_3": "Crusader",
"rank_tier_4": "Archon",
"rank_tier_5": "Legend",
"rank_tier_6": "Ancient",
"rank_tier_7": "Divine",
"rank_tier_8": "Immortal",
"request_title": "ร้องขอการวิเคราะห์แมตช์",
"request_match_id": "ไอดีแมตช์",
"request_invalid_match_id": "ไอดีแมตช์ไม่ถูกต้อง",
"request_error": "ล้มเหลวในการรับข้อมูลแมตช์",
"request_submit": "ส่ง",
"roaming": "เดินเกม",
"rune_0": "Double Damage",
"rune_1": "Haste",
"rune_2": "Illusion",
"rune_3": "Invisibility",
"rune_4": "Regeneration",
"rune_5": "Bounty",
"rune_6": "Arcane",
"rune_7": "Water",
"search_title": "ค้นหาโดยชื่อผู้เล่น ไอดีแมตช์...",
"skill_0": "ไม่ทราบ",
"skill_1": "ทักษะปกติ",
"skill_2": "ทักษะสูง",
"skill_3": "ทักษะสูงมาก",
"story_invalid_template": "(เทมเพลตผิดพลาด)",
"story_error": "เกิดข้อผิดพลาดขณะกำลังรวบรวมเรื่องราวของแมตช์นี้",
"story_intro": "ใน{date} ทั้งสองทีมได้ตกลงปลงใจกันเล่นเกม Dota 2 โหมด {game_mode_article} {game_mode} ในโซน{region} ไม่มีใครคาดคิดเลยว่าเกมนี้จะใช้เวลา{duration_in_words}",
"story_invalid_hero": "ฮีโร่ที่ไม่รู้จัก",
"story_fullstop": " ",
"story_list_2": "{1} และ {2}",
"story_list_3": "{1} {2} และ {3}",
"story_list_n": "{i} {rest}",
"story_firstblood": "{killer} ได้เปิดฉาก First Blood โดยสังหาร {victim} เมื่อเริ่มเกมมาจนถึงเวลา {time}",
"story_chatmessage": "\"{message}\" {player} {said_verb}",
"story_teamfight": "{winning_team} เอาชนะการต่อสู้เป็นทีมได้โดยยอมสละ {win_dead} เพื่อแลกกับค่าหัวของ {lose_dead} ทำให้รายได้สุทธิของทีมเพิ่มขึ้น {net_change}",
"story_teamfight_none_dead": "{winning_team} เอาชนะการต่อสู้เป็นทีมได้ด้วยการสังหาร {lose_dead} โดยฮีโร่ในทีมทั้งหมดยังอยู่ครบ ทำให้รายได้สุทธิของทีมเพิ่มขึ้น {net_change}",
"story_teamfight_none_dead_loss": "{winning_team} เอาชนะการต่อสู้เป็นทีมได้โดยไม่ได้สังหารใครเลย แต่ทว่าได้สูญเสีย {win_dead} ทำให้รายได้สุทธิของทีมเพิ่มขึ้น {net_change}",
"story_lane_intro": "เมื่อเกมดำเนินผ่านไป 10 นาที ผลลัพธ์ช่วงในเลนออกมาเป็นดังนี้:",
"story_lane_radiant_win": "{radiant_players} เอาชนะ{lane}ด้วยการกำราบ {dire_players}",
"story_lane_radiant_lose": "{radiant_players} พ่ายแพ้{lane}ให้กับ {dire_players}",
"story_lane_draw": "{radiant_players} เสมอ{lane}อย่างสูสีกับ {dire_players}",
"story_lane_free": "{players} ได้ฟาร์มใน{lane}อย่างสบายใจ",
"story_lane_empty": "ไม่มีใครอยู่ใน{lane}เลย",
"story_lane_jungle": "{players} ฟาร์มครีปป่า",
"story_lane_roam": "{players} เดินเกม",
"story_roshan": "ฝ่าย {team} ได้สังหาร Roshan",
"story_aegis": "{player} {action} Aegis of the Immortal",
"story_gameover": "แมตช์นี้สิ้นสุดลงด้วยชัยชนะของฝ่าย {winning_team} ด้วยเวลา {duration} แต้มสังหาร {radiant_score} ต่อ {dire_score}",
"story_during_teamfight": "ในระหว่างที่ทั้งสองทีมกำลังต่อสู้กันอยู่นั้น {events}",
"story_after_teamfight": "หลังจากสิ้นสุดการต่อสู้ {events}",
"story_expensive_item": "เมื่อเกมดำเนินมาถึงเวลา {time} {player} ได้ซื้อ {item} ซึ่งเป็นไอเท็มชิ้นแรกในเกมที่มีราคาสูงกว่า {price_limit}",
"story_building_destroy": "{building} ถูกทำลาย",
"story_building_destroy_player": "{player} ได้ทำลาย{building}",
"story_building_deny_player": "{player} ได้สละ {building}",
"story_building_list_destroy": "{buildings} ถูกทำลาย",
"story_courier_kill": "Courier ของฝ่าย {team} ถูกสังหาร",
"story_tower": "ป้อม{lane}ชั้นที่ {tier} ของ {team}",
"story_tower_simple": "หนึ่งในป้อมของฝ่าย {team}",
"story_towers_n": "{n} ป้อมของฝ่าย {team}",
"story_barracks": "{rax_type}{lane}ของฝ่าย {team}",
"story_barracks_both": "บาร์แร็ก{lane}ทั้งสองของฝ่าย {team}",
"story_time_marker": "ผ่านไป {minutes} นาที",
"story_item_purchase": "{player} ซื้อ {item} ณ เวลา {time}",
"story_predicted_victory": "{players} ได้ทำนายว่าฝ่าย {team} จะชนะ",
"story_predicted_victory_empty": "ไม่มีผู้เล่นคนใด",
"story_networth_diff": "ต่างกัน {percent}% / {gold}",
"story_gold": "โกลด์",
"story_chat_asked": "เอ่ยปากถาม",
"story_chat_said": "พูด",
"tab_overview": "ภาพรวม",
"tab_matches": "แมตช์",
"tab_heroes": "ฮีโร่",
"tab_peers": "เพื่อน",
"tab_pros": "ผู้เล่นมืออาชีพ",
"tab_activity": "กิจกรรม",
"tab_records": "สถิติ",
"tab_totals": "ยอดรวม",
"tab_counts": "จำนวนเกม",
"tab_histograms": "ฮิสโตแกรม",
"tab_trends": "แนวโน้ม",
"tab_items": "ไอเท็ม",
"tab_wardmap": "แผนที่ Ward",
"tab_wordcloud": "กลุ่มคำ",
"tab_mmr": "MMR",
"tab_rankings": "อันดับ",
"tab_drafts": "การดราฟท์",
"tab_benchmarks": "การเทียบสมรรถนะ",
"tab_performances": "ประสิทธิภาพ",
"tab_damage": "ความเสียหาย",
"tab_purchases": "ซื้อ",
"tab_farm": "การฟาร์ม",
"tab_combat": "การต่อสู้",
"tab_graphs": "กราฟ",
"tab_casts": "ร่ายสกิล",
"tab_vision": "วิสัยทัศน์",
"tab_objectives": "เป้าหมาย",
"tab_teamfights": "การต่อสู้เป็นทีม",
"tab_actions": "กดคำสั่ง",
"tab_analysis": "การวิเคราะห์",
"tab_cosmetics": "ไอเท็มตกแต่ง",
"tab_log": "บันทึก",
"tab_chat": "แช็ต",
"tab_story": "เรื่องราว",
"tab_fantasy": "Fantasy",
"tab_laning": "ช่วงในเลน",
"tab_recent": "ล่าสุด",
"tab_matchups": "การจับคู่",
"tab_durations": "ระยะเวลา",
"tab_players": "ผู้เล่น",
"placeholder_filter_heroes": "กรองฮีโร่",
"td_win": "ชนะแมตช์",
"td_loss": "แพ้แมตช์",
"td_no_result": "ไม่มีผลลัพธ์",
"th_hero_id": "ฮีโร่",
"th_match_id": "ID",
"th_account_id": "ID บัญชี",
"th_result": "ผลลัพธ์",
"th_skill": "ทักษะ",
"th_duration": "ระยะเวลา",
"th_games": "จำนวนแมตช์",
"th_games_played": "เกม",
"th_win": "% ชนะ",
"th_advantage": "ได้เปรียบ",
"th_with_games": "ร่วมทีม",
"th_with_win": "% ชนะร่วมทีม",
"th_against_games": "ฝ่ายตรงข้าม",
"th_against_win": "% ชนะฝ่ายตรงข้าม",
"th_gpm_with": "GPM ร่วมทีม",
"th_xpm_with": "XPM ร่วมทีม",
"th_avatar": "ผู้เล่น",
"th_last_played": "สุดท้าย",
"th_record": "สถิติ",
"th_title": "ชื่อ",
"th_category": "หมวดหมู่",
"th_matches": "แมตช์",
"th_percentile": "อันดับเปอร์เซ็น",
"th_rank": "อันดับ",
"th_items": "ไอเท็ม",
"th_stacked": "ลากครีป",
"th_multikill": "สังหารหลายคน",
"th_killstreak": "สังหารต่อเนื่อง",
"th_stuns": "สตัน",
"th_dead": "ตาย",
"th_buybacks": "ซื้อเกิด",
"th_biggest_hit": "โจมตีแรงสุด",
"th_lane": "เลน",
"th_map": "แผนที่",
"th_lane_efficiency": "EFF@10",
"th_lhten": "LH@10",
"th_dnten": "DN@10",
"th_tpscroll": "TP",
"th_ward_observer": "Ward",
"th_ward_sentry": "Sentry",
"th_smoke_of_deceit": "Smoke",
"th_dust": "Dust",
"th_gem": "Gem",
"th_time": "เวลา",
"th_message": "ข้อความ",
"th_heroes": "ฮีโร่",
"th_creeps": "ครีป",
"th_neutrals": "ครีปป่า",
"th_ancients": "ครีป Ancient",
"th_towers": "ป้อม",
"th_couriers": "Courier",
"th_roshan": "Roshan",
"th_necronomicon": "Necronomicon",
"th_other": "อื่น ๆ",
"th_cosmetics": "ไอเท็มตกแต่ง",
"th_damage_received": "ได้รับความเสียหาย",
"th_damage_dealt": "สร้างความเสียหาย",
"th_players": "ผู้เล่น",
"th_analysis": "การวิเคราะห์",
"th_death": "ตาย",
"th_damage": "ความเสียหาย",
"th_healing": "รักษา",
"th_net_worth": "NET",
"th_gold": "โกลด์",
"th_xp": "XP",
"th_abilities": "สกิล",
"th_target_abilities": "สกิลกำหนดเป้าหมาย",
"th_mmr": "MMR",
"th_level": "เลเวล",
"th_kills": "K",
"th_kills_per_min": "KPM",
"th_deaths": "D",
"th_assists": "A",
"th_last_hits": "LH",
"th_last_hits_per_min": "LHM",
"th_denies": "DN",
"th_gold_per_min": "GPM",
"th_xp_per_min": "XPM",
"th_stuns_per_min": "SPM",
"th_hero_damage": "HD",
"th_hero_damage_per_min": "HDM",
"th_hero_healing": "HH",
"th_hero_healing_per_min": "HHM",
"th_tower_damage": "TD",
"th_tower_damage_per_min": "TDM",
"th_kda": "KLA",
"th_actions_per_min": "APM",
"th_pings": "PNG (M)",
"th_DOTA_UNIT_ORDER_MOVE_TO_POSITION": "MV (P)",
"th_DOTA_UNIT_ORDER_MOVE_TO_TARGET": "MV (T)",
"th_DOTA_UNIT_ORDER_ATTACK_TARGET": "ATK (T)",
"th_DOTA_UNIT_ORDER_ATTACK_MOVE": "ATK (P)",
"th_DOTA_UNIT_ORDER_CAST_POSITION": "CST (P)",
"th_DOTA_UNIT_ORDER_CAST_TARGET": "CST (T)",
"th_DOTA_UNIT_ORDER_CAST_NO_TARGET": "CST (N)",
"th_DOTA_UNIT_ORDER_HOLD_POSITION": "HLD",
"th_DOTA_UNIT_ORDER_GLYPH": "GLYPH",
"th_DOTA_UNIT_ORDER_RADAR": "SCN",
"th_ability_builds": "สกิล",
"th_purchase_shorthand": "ซื้อ",
"th_use_shorthand": "ใช้",
"th_duration_shorthand": "เวลา",
"th_country": "ประเทศ",
"th_count": "จำนวน",
"th_sum": "รวม",
"th_average": "ค่าเฉลี่ย",
"th_name": "ชื่อ",
"th_team_name": "ชื่อทีม",
"th_score": "แต้ม",
"th_casts": "ร่ายสกิล",
"th_hits": "ครั้ง",
"th_wins": "ชนะ",
"th_losses": "แพ้",
"th_winrate": "อัตราการชนะ",
"th_solo_mmr": "MMR เดี่ยว",
"th_party_mmr": "MMR ปาร์ตี้",
"th_estimated_mmr": "MMR โดยประมาณ",
"th_permanent_buffs": "บัฟ",
"th_winner": "ผู้ชนะ",
"th_played_with": "สถิติร่วมกัน",
"th_obs_placed": "ปัก Ward",
"th_sen_placed": "ปัก Sentry",
"th_obs_destroyed": "ทำลาย Observer",
"th_sen_destroyed": "ทำลาย Sentry",
"th_scans_used": "ใช้การสแกน",
"th_glyphs_used": "ใช้งาน Glyph",
"th_legs": "นัดแข่ง",
"th_fantasy_points": "แต้ม Fantasy",
"th_rating": "คะแนน",
"th_teamfight_participation": "การมีส่วนร่วม",
"th_firstblood_claimed": "First Blood",
"th_observers_placed": "Ward",
"th_camps_stacked": "ลาก",
"th_league": "ลีก",
"th_attack_type": "ประเภทการโจมตี",
"th_primary_attr": "ค่าสถานะหลัก",
"th_opposing_team": "ทีมฝ่ายตรงข้าม",
"ward_log_type": "ประเภท",
"ward_log_owner": "เจ้าของ",
"ward_log_entered_at": "ปัก",
"ward_log_left_at": "หมด",
"ward_log_duration": "ระยะเวลา",
"ward_log_killed_by": "ทำลายโดย",
"log_detail": "รายละเอียด",
"log_heroes": "ระบุฮีโร่",
"tier_professional": "ระดับมืออาชีพ",
"tier_premium": "พรีเมียม",
"time_past": "{0}ที่ผ่านมา",
"time_just_now": "เมื่อสักครู่นี้",
"time_s": "1 วินาที",
"time_abbr_s": "{0} วิ",
"time_ss": "{0} วินาที",
"time_abbr_ss": "{0} วิ",
"time_m": "1 นาที",
"time_abbr_m": "{0} น",
"time_mm": "{0} นาที",
"time_abbr_mm": "{0} น",
"time_h": "1 ชั่วโมง",
"time_abbr_h": "{0} ช",
"time_hh": "{0} ชั่วโมง",
"time_abbr_hh": "{0} ช",
"time_d": "1 วัน",
"time_abbr_d": "{0} ว",
"time_dd": "{0} วัน",
"time_abbr_dd": "{0} ว",
"time_M": "1 เดือน",
"time_abbr_M": "{0} ด",
"time_MM": "{0} เดือน",
"time_abbr_MM": "{0} ด",
"time_y": "1 ปี",
"time_abbr_y": "{0} ปี",
"time_yy": "{0} ปี",
"time_abbr_yy": "{0} ปี",
"timeline_firstblood": "เก็บ First Blood",
"timeline_firstblood_key": "ได้เปิดฉาก First Blood โดยสังหาร",
"timeline_aegis_picked_up": "เป็นผู้เก็บ",
"timeline_aegis_snatched": "ขโมย",
"timeline_aegis_denied": "ทำลาย",
"timeline_teamfight_deaths": "ตาย",
"timeline_teamfight_gold_delta": "โกลด์ Δ",
"title_default": "OpenDota - สถิติ Dota 2",
"title_template": "%s - OpenDota - สถิติ Dota 2",
"title_matches": "แมตช์",
"title_request": "ร้องขอการวิเคราะห์แมตช์",
"title_search": "ค้นหา",
"title_status": "สถานะ",
"title_explorer": "โปรแกรมสำรวจข้อมูล",
"title_meta": "เมต้า",
"title_records": "สถิติ",
"title_api": "Opendota API: สถิติ Dota 2 ขั้นสูงสำหรับแอปของคุณ",
"tooltip_mmr": "MMR เดี่ยวของผู้เล่น",
"tooltip_cs_over_time": "จำนวนครีปในแต่ละนาที ช่วง 10 นาทีแรก",
"tooltip_abilitydraft": "สกิลที่เลือก",
"tooltip_level": "เลเวลของฮีโร่",
"tooltip_kills": "จำนวนการสังหารโดยฮีโร่",
"tooltip_deaths": "จำนวนการตายของฮีโร่",
"tooltip_assists": "จำนวนการช่วยเหลือของฮีโร่",
"tooltip_last_hits": "จำนวนการ Last Hit ของฮีโร่",
"tooltip_denies": "จำนวนการ Deny ครีป",
"tooltip_gold": "โกลด์ที่ฟาร์มได้ทั้งหมด",
"tooltip_net_worth": "รายได้สุทธิของฮีโร่",
"tooltip_gold_per_min": "โกลด์ที่ฟาร์มได้ต่อนาที",
"tooltip_xp_per_min": "ค่าประสบการณ์ที่ได้รับต่อนาที",
"tooltip_stuns_per_min": "วินาทีที่หยุดฮีโร่ต่อนาที",
"tooltip_last_hits_per_min": "จำนวน Last Hit ต่อนาที",
"tooltip_kills_per_min": "จำนวนการสังหารต่อนาที",
"tooltip_hero_damage_per_min": "ความเสียหายฮีโร่ต่อนาที",
"tooltip_hero_healing_per_min": "รักษาฮีโร่ต่อนาที",
"tooltip_tower_damage_per_min": "ความเสียหายป้อมต่อนาที",
"tooltip_actions_per_min": "จำนวนการกดคำสั่งโดยผู้เล่นต่อหนึ่งนาที",
"tooltip_hero_damage": "จำนวนความเสียหายที่สร้างต่อฮีโร่",
"tooltip_tower_damage": "จำนวนความเสียหายที่สร้างต่อป้อม",
"tooltip_hero_healing": "จำนวนการรักษาพลังชีวิตต่อฮีโร่",
"tooltip_duration": "ระยะเวลาของแมตช์",
"tooltip_first_blood_time": "เวลาที่ First Blood เกิดขึ้น",
"tooltip_kda": "(สังหาร + ช่วยเหลือ) / (ตาย + 1)",
"tooltip_stuns": "จำนวนวินาทีที่หยุดฮีโร่",
"tooltip_dead": "ระยะเวลาที่ตาย",
"tooltip_buybacks": "จำนวนการซื้อเกิด",
"tooltip_camps_stacked": "จำนวนแคมป์ที่ลากครีป",
"tooltip_tower_kills": "จำนวนป้อมที่ทำลาย",
"tooltip_neutral_kills": "จำนวนครีปป่าที่สังหาร",
"tooltip_courier_kills": "จำนวน Courier ที่สังหาร",
"tooltip_purchase_tpscroll": "จำนวน Town Portal Scroll ที่ซื้อ",
"tooltip_purchase_ward_observer": "จำนวน Observer Ward ที่ซื้อ",
"tooltip_purchase_ward_sentry": "จำนวน Sentry Ward ที่ซื้อ",
"tooltip_purchase_smoke_of_deceit": "จำนวน Smoke of Deceit ที่ซื้อ",
"tooltip_purchase_dust": "จำนวน Dust of Appearance ที่ซื้อ",
"tooltip_purchase_gem": "จำนวน Gem of True Sight ที่ซื้อ",
"tooltip_purchase_rapier": "จำนวน Divine Rapier ที่ซื้อ",
"tooltip_purchase_buyback": "จำนวนการซื้อเกิด",
"tooltip_duration_observer": "ระยะเวลาของ Observer Ward โดยเฉลี่ย",
"tooltip_duration_sentry": "ระยะเวลาของ Sentry Ward โดยเฉลี่ย",
"tooltip_used_ward_observer": "จำนวน Observer Wards ที่ปักระหว่างเกม",
"tooltip_used_ward_sentry": "จำนวน Sentry Wards ที่ปักระหว่างเกม",
"tooltip_used_dust": "จำนวน Dust of Appearance ที่ใช้ระหว่างเกม",
"tooltip_used_smoke_of_deceit": "จำนวน Smoke of Deceit ที่ใช้ระหว่างเกม",
"tooltip_parsed": "รีเพลย์ได้ถูกวิเคราะห์เพื่อเก็บข้อมูลเพิ่มเติมแล้ว",
"tooltip_unparsed": "รีเพลย์ของแมตช์นี้ยังไม่ได้รับการวิเคราะห์ อาจไม่สามารถเข้าถึงข้อมูลบางส่วนได้",
"tooltip_hero_id": "ฮีโร่ที่เล่น",
"tooltip_result": "ผู้เล่นชนะหรือแพ้",
"tooltip_match_id": "หมายเลข ID ของแมตช์",
"tooltip_game_mode": "โหมดเกมของแมตช์",
"tooltip_skill": "MMR โดยประมาณที่ใช้ตัดแบ่งระดับคือ 0, 3200 และ 3700",
"tooltip_ended": "เวลาที่แมตช์สิ้นสุด",
"tooltip_pick_order": "ลำดับการเลือกของผู้เล่น",
"tooltip_throw": "จำนวนโกลด์ได้เปรียบในเกมที่แพ้สูงสุด",
"tooltip_comeback": "จำนวนโกลด์เสียเปรียบในเกมที่ชนะสูงสุด",
"tooltip_stomp": "จำนวนโกลด์ได้เปรียบในเกมที่ชนะสูงสุด",
"tooltip_loss": "จำนวนโกลด์เสียเปรียบในเกมที่แพ้สูงสุด",
"tooltip_items": "แนวทางไอเท็ม",
"tooltip_permanent_buffs": "บัฟถาวร เช่น Flesh Heap หรือการใช้ Tomes of Knowledge",
"tooltip_lane": "การยืนเลนจากตำแหน่งในช่วงต้นเกม",
"tooltip_map": "ฮีตแมปของตำแหน่งผู้เล่นในช่วงต้นเกม",
"tooltip_lane_efficiency": "เปอร์เซ็นต์ของโกลด์ในเลน (ครีป+ติดตัว+เริ่มต้น) ที่ได้รับช่วง 10 นาทีแรก",
"tooltip_lane_efficiency_pct": "เปอร์เซ็นต์ของโกลด์ในเลน (ครีป+ติดตัว+เริ่มต้น) ที่ได้รับช่วง 10 นาทีแรก",
"tooltip_pings": "จำนวนครั้งที่ผู้เล่นกดชี้เตือนในแมป",
"tooltip_DOTA_UNIT_ORDER_MOVE_TO_POSITION": "จำนวนครั้งที่ผู้เล่นเคลื่อนที่ไปยังตำแหน่ง",
"tooltip_DOTA_UNIT_ORDER_MOVE_TO_TARGET": "จำนวนครั้งที่ผู้เล่นเคลื่อนที่ไปยังเป้าหมาย",
"tooltip_DOTA_UNIT_ORDER_ATTACK_MOVE": "จำนวนครั้งที่ผู้เล่นโจมตีตำแหน่ง (เคลื่อนที่พร้อมโจมตี)",
"tooltip_DOTA_UNIT_ORDER_ATTACK_TARGET": "จำนวนครั้งที่ผู้เล่นโจมตีเป้าหมาย",
"tooltip_DOTA_UNIT_ORDER_CAST_POSITION": "จำนวนครั้งที่ผู้เล่นร่ายสกิลใส่ตำแหน่ง",
"tooltip_DOTA_UNIT_ORDER_CAST_TARGET": "จำนวนครั้งที่ผู้เล่นร่ายสกิลใส่เป้าหมาย",
"tooltip_DOTA_UNIT_ORDER_CAST_NO_TARGET": "จำนวนครั้งที่ผู้เล่นร่ายสกิลแบบไร้เป้าหมาย",
"tooltip_DOTA_UNIT_ORDER_HOLD_POSITION": "จำนวนครั้งที่ผู้เล่นประจำตำแหน่ง",
"tooltip_DOTA_UNIT_ORDER_GLYPH": "จำนวนครั้งที่ผู้เล่นใช้งาน Glyph",
"tooltip_DOTA_UNIT_ORDER_RADAR": "จำนวนครั้งที่ผู้เล่นใช้การสแกน",
"tooltip_last_played": "ครั้งสุดท้ายที่เล่นแมตช์กับผู้เล่น/ฮีโร่นี้",
"tooltip_matches": "แมตช์ที่เล่นร่วมทีม/ฝ่ายตรงข้ามกับผู้เล่นนี้",
"tooltip_played_as": "จำนวนแมตช์ที่เล่นเป็นฮีโร่นี้",
"tooltip_played_with": "จำนวนแมตช์ที่เล่นร่วมกับผู้เล่น/ฮีโร่นี้ในทีม",
"tooltip_played_against": "จำนวนแมตช์ที่เล่นกับผู้เล่น/ฮีโร่นี้ในทีมฝ่ายตรงข้าม",
"tooltip_tombstone_victim": "ที่แห่งนี้มีร่างของ",
"tooltip_tombstone_killer": "ทำลายโดย",
"tooltip_win_pct_as": "อัตราการชนะโดยฮีโร่นี้",
"tooltip_win_pct_with": "อัตราการชนะเมื่อเล่นร่วมทีมกับผู้เล่น/ฮีโร่นี้",
"tooltip_win_pct_against": "อัตราการชนะเมื่อเล่นกับผู้เล่น/ฮีโร่นี้ในทีมฝ่ายตรงข้าม",
"tooltip_lhten": "จำนวนการ Last Hit ที่ 10 นาทีแรกของเกม",
"tooltip_dnten": "จำนวนการ Deny ที่ 10 นาทีแรกของเกม",
"tooltip_biggest_hit": "ความเสียหายต่อศัตรูที่สูงที่สุด",
"tooltip_damage_dealt": "ความเสียหายที่สร้างต่อฮีโร่ด้วยไอเท็ม/สกิล",
"tooltip_damage_received": "ความเสียหายที่ได้รับจากฮีโร่ด้วยไอเท็ม/สกิล",
"tooltip_registered_user": "ผู้ใช้งานลงทะเบียนแล้ว",
"tooltip_dotaplus": "สมาชิก Dota Plus",
"tooltip_ability_builds": "แนวทางสกิล",
"tooltip_ability_builds_expired": "ข้อมูลการอัปเกรดสกิลของแมตช์นี้หมดอายุแล้ว ใช้แบบฟอร์มส่งคำขอเพื่อโหลดข้อมูลใหม่",
"tooltip_multikill": "สังหารฮีโร่หลายตัวมากที่สุด",
"tooltip_killstreak": "สังหารฮีโร่ต่อเนื่องมากที่สุด",
"tooltip_casts": "จำนวนครั้งที่สกิล/ไอเท็มนี้ถูกกดใช้งาน",
"tooltip_target_abilities": "จำนวนครั้งที่ฮีโร่แต่ละตัวเป็นเป้าหมายสกิลของฮีโร่นี้",
"tooltip_hits": "จำนวนครั้งที่สร้างความเสียหายโดยสกิล/ไอเท็มนี้",
"tooltip_damage": "จำนวนครั้งที่สร้างความเสียหายต่อฮีโร่โดยสกิล/ไอเท็มนี้",
"tooltip_autoattack_other": "โจมตีอัตโนมัติ/อื่น ๆ",
"tooltip_estimated_mmr": "MMR โดยประมาณจากค่าเฉลี่ย MMR ที่เปิดเผยจากแมตช์ล่าสุดโดยผู้ใช้งานนี้",
"tooltip_backpack": "กระเป๋า",
"tooltip_others_tracked_deaths": "ตายเมื่อโดน Track",
"tooltip_others_track_gold": "โกลด์ที่ได้รับจาก Track",
"tooltip_others_greevils_gold": "โกลด์ที่ได้รับจาก Greevil's Greed",
"tooltip_advantage": "คำนวณโดยคะแนน Wilson",
"tooltip_winrate_samplesize": "อัตราการชนะและขนาดของกลุ่มตัวอย่าง",
"tooltip_teamfight_participation": "การมีส่วนร่วมในการต่อสู้เป็นทีม",
"tooltip_hero_rankings_score": "คะแนนจะเพิ่มขึ้นเมื่อชนะ และลดลงเมื่อแพ้ คะแนนที่ได้จะขึ้นอยู่กับ MMR เฉลี่ยในแมตช์",
"histograms_name": "ฮิสโตแกรม",
"histograms_description": "เปอร์เซ็นต์บ่งชี้อัตราการชนะจากค่ากำหนดที่เลือก",
"histograms_actions_per_min_description": "จำนวนการกดคำสั่งโดยผู้เล่นต่อหนึ่งนาที",
"histograms_comeback_description": "จำนวนโกลด์เสียเปรียบในเกมที่ชนะสูงสุด",
"histograms_lane_efficiency_pct_description": "เปอร์เซ็นต์ของโกลด์ในเลน (ครีป+ติดตัว+เริ่มต้น) ที่ได้รับช่วง 10 นาทีแรก",
"histograms_gold_per_min_description": "โกลด์ที่ฟาร์มได้ต่อนาที",
"histograms_hero_damage_description": "จำนวนความเสียหายที่สร้างต่อฮีโร่",
"histograms_hero_healing_description": "จำนวนการรักษาพลังชีวิตต่อฮีโร่",
"histograms_level_description": "เลเวลในแมตช์",
"histograms_loss_description": "จำนวนโกลด์เสียเปรียบในเกมที่แพ้สูงสุด",
"histograms_pings_description": "จำนวนครั้งที่ผู้เล่นกดชี้เตือนในแมป",
"histograms_stomp_description": "จำนวนโกลด์ได้เปรียบในเกมที่ชนะสูงสุด",
"histograms_stuns_description": "จำนวนวินาทีที่หยุดฮีโร่",
"histograms_throw_description": "จำนวนโกลด์ได้เปรียบในเกมที่แพ้สูงสุด",
"histograms_purchase_tpscroll_description": "จำนวน Town Portal Scroll ที่ซื้อ",
"histograms_xp_per_min_description": "ค่าประสบการณ์ที่ได้รับต่อนาที",
"trends_name": "เทรนด์",
"trends_description": "ค่าเฉลี่ยเคลื่อนที่จาก 20 เกมล่าสุด",
"trends_tooltip_average": "ค่าเฉลี่ย",
"trends_no_data": "ขออภัย ไม่มีข้อมูลสำหรับกราฟนี้",
"xp_reasons_0": "อื่น ๆ",
"xp_reasons_1": "ฮีโร่",
"xp_reasons_2": "ครีป",
"xp_reasons_3": "Roshan",
"rankings_description": "",
"rankings_none": "ผู้เล่นนี้ไม่ติดอันดับฮีโร่ใด ๆ เลย",
"region_0": "อัตโนมัติ",
"region_1": "อเมริกาตะวันตก",
"region_2": "อเมริกาตะวันออก",
"region_3": "ลักเซมเบิร์ก",
"region_5": "สิงคโปร์",
"region_6": "ดูไบ",
"region_7": "ออสเตรเลีย",
"region_8": "สตอกโฮล์ม",
"region_9": "ออสเตรีย",
"region_10": "บราซิล",
"region_11": "แอฟริกาใต้",
"region_12": "China TC เซี่ยงไฮ้",
"region_13": "China UC",
"region_14": "ชิลี",
"region_15": "เปรู",
"region_16": "อินเดีย",
"region_17": "China TC กวางตุ้ง",
"region_18": "China TC เจ้อเจียง",
"region_19": "ญี่ปุ่น",
"region_20": "China TC อู่ฮั่น",
"region_25": "China UC 2",
"vision_expired": "หมดเวลาหลังจาก",
"vision_destroyed": "ถูกทำลายหลังจาก",
"vision_all_time": "ทุกช่วงเวลา",
"vision_placed_observer": "ปัก Observer Ward ณ เวลา",
"vision_placed_sentry": "ปัก Sentry Ward ณ เวลา",
"vision_ward_log": "บันทึกการปัก Ward",
"chat_category_faction": "ฝ่าย",
"chat_category_type": "ประเภท",
"chat_category_target": "เป้าหมาย",
"chat_category_other": "อื่น ๆ",
"chat_filter_text": "ข้อความ",
"chat_filter_phrases": "วลี",
"chat_filter_audio": "เสียง",
"chat_filter_spam": "สแปม",
"chat_filter_all": "ทั้งหมด",
"chat_filter_allies": "เพื่อนร่วมทีม",
"chat_filter_spectator": "ผู้เข้าชม",
"chat_filtered": "กรองแล้ว",
"advb_almost": "เกือบ",
"advb_over": "กว่า",
"advb_about": "ประมาณ",
"article_before_consonant_sound": " ",
"article_before_vowel_sound": " ",
"statement_long": "ตั้งสมมุติฐาน",
"statement_shouted": "ตะโกน",
"statement_excited": "อุทาน",
"statement_normal": "แสดงความคิดเห็น",
"statement_laughed": "หัวเราะ",
"question_long": "ตั้งคำถามด้วยความสงสัย และต้องการคำตอบ",
"question_shouted": "สอบถาม",
"question_excited": "ซักถาม",
"question_normal": "เอ่ยปากถาม",
"question_laughed": "หัวเราะล้อเลียน",
"statement_response_long": "แนะนำ",
"statement_response_shouted": "ตอบด้วยความไม่พอใจ",
"statement_response_excited": "อุทาน",
"statement_response_normal": "ตอบกลับ",
"statement_response_laughed": "แค่นหัวเราะ",
"statement_continued_long": "โวยวาย",
"statement_continued_shouted": "แหกปากด้วยความหัวร้อน",
"statement_continued_excited": "พูดพล่าม",
"statement_continued_normal": "กล่าวเสริม",
"statement_continued_laughed": "พล่ามต่อ",
"question_response_long": "แนะนำ",
"question_response_shouted": "สวนกลับ ด้วยความไม่พอใจ",
"question_response_excited": "เถียง",
"question_response_normal": "พูดแย้ง",
"question_response_laughed": "หัวเราะเยาะ",
"question_continued_long": "ยื่นข้อเสนอ",
"question_continued_shouted": "ถามด้วยอาการหัวร้อน",
"question_continued_excited": "ถามอย่างตั้งใจ",
"question_continued_normal": "เอ่ยปากถาม",
"question_continued_laughed": "ถามด้วยอารมณ์ขัน",
"hero_disclaimer_pro": "ข้อมูลจากแมตช์ระดับมืออาชีพ",
"hero_disclaimer_public": "ข้อมูลจากแมตช์สาธารณะ",
"hero_duration_x_axis": "นาที",
"top_tower": "ป้อมบน",
"bot_tower": "ป้อมล่าง",
"mid_tower": "ป้อมกลาง",
"top_rax": "บาร์แร็กฝั่งบน",
"bot_rax": "บาร์แร็กฝั่งล่าง",
"mid_rax": "บาร์แร็กกลาง",
"tier1": "ชั้นที่ 1",
"tier2": "ชั้นที่ 2",
"tier3": "ชั้นที่ 3",
"tier4": "ชั้นที่ 4",
"show_consumables_items": "แสดงไอเท็มของใช้แล้วหมดไป",
"activated": "เปิดใช้งาน",
"rune": "รูน",
"placement": "ตำแหน่ง",
"include_turbo_matches": "รวมแมตช์ Turbo",
"scenarios_subtitle": "สำรวจอัตราการชนะจากปัจจัยต่าง ๆ ที่เกิดขึ้นในแมตช์",
"scenarios_info": "ข้อมูลถูกรวบรวมจากแมตช์ใน {0} สัปดาห์ล่าสุด",
"scenarios_item_timings": "เวลาการออกไอเท็ม",
"scenarios_misc": "เบ็ดเตล็ด",
"scenarios_time": "เวลา",
"scenarios_item": "ไอเท็ม",
"scenarios_game_duration": "ระยะเวลาแมตช์",
"scenarios_scenario": "สถานการณ์",
"scenarios_first_blood": "ทีมได้ First Blood",
"scenarios_courier_kill": "ทีมสังหาร Courier ได้ก่อน 3 นาทีในเกม",
"scenarios_pos_chat_1min": "ทีมส่งข้อความแช็ตแง่บวกก่อน 1 นาทีในเกม",
"scenarios_neg_chat_1min": "ทีมส่งข้อความแช็ตแง่ลบก่อน 1 นาทีในเกม",
"gosu_default": "รับคำแนะนำส่วนตัว",
"gosu_benchmarks": "ประเมินประสิทธิภาพโดยละเอียดสำหรับฮีโร่ ช่วงในเลน และตำแหน่งของคุณ",
"gosu_performances": "ประเมินประสิทธิภาพในการควบคุมแผนที่ของคุณ",
"gosu_laning": "รู้สาเหตุที่คุณพลาด Last Hit",
"gosu_combat": "ทำความเข้าใจว่าเหตุใดความพยายามในการฆ่าจึงไม่สำเร็จ",
"gosu_farm": "รู้สาเหตุที่คุณพลาด Last Hit",
"gosu_vision": "ทราบจำนวนฮีโร่ที่ถูกสังหารด้วย Ward ของคุณ",
"gosu_actions": "ทราบจำนวนเวลาที่คุณเสียไปจากการใช้เมาส์ vs คีย์ลัด",
"gosu_teamfights": "รู้ว่าควรจะจัดการใครในการต่อสู้เป็นทีม",
"gosu_analysis": "มุ่งสู่ MMR ที่แท้จริงของคุณ",
"back2Top": "กลับไปบนสุด",
"activity_subtitle": "คลิกที่วันเพื่อดูข้อมูลโดยละเอียด",
"vs": "ปะทะ",
"add_team": "เพิ่มเข้าทีม {0}",
"team": "ทีม {0}",
"combos": "คอมโบ",
"combos_title": "คอมโบฮีโร่",
"combos_description": "ค้นหาพันธมิตรฮีโร่ในแมตช์สาธารณะและแมตช์ระดับมืออาชีพ",
"public_matches": "แมตช์สาธารณะ",
"pro_matches": "แมตช์ระดับมืออาชีพ"
}
| odota/web/src/lang/th-TH.json/0 | {
"file_path": "odota/web/src/lang/th-TH.json",
"repo_id": "odota",
"token_count": 45435
} | 277 |
import heroes from 'dotaconstants/build/heroes.json';
import itemIds from 'dotaconstants/build/item_ids.json';
import patch from 'dotaconstants/build/patch.json';
import xpLevel from 'dotaconstants/build/xp_level.json';
import curry from 'lodash/fp/curry';
import findLast from 'lodash/fp/findLast';
import inRange from 'lodash/fp/inRange';
// import SvgIcon from 'material-ui/SvgIcon';
import SocialPeople from 'material-ui/svg-icons/social/people';
import SocialPerson from 'material-ui/svg-icons/social/person';
import querystring from 'querystring';
import React from 'react';
import { Link } from 'react-router-dom';
import ReactTooltip from 'react-tooltip';
import constants from '../components/constants';
import { TableLink } from '../components/Table';
import {
FromNowTooltip,
KDA,
TableHeroImage,
} from '../components/Visualizations';
import store from '../store';
import config from '../config';
const items = (await import('dotaconstants/build/items.json')).default;
const second = 1;
const minute = second * 60;
const hour = minute * 60;
const day = hour * 24;
const month = day * 30;
const year = month * 12;
export const iconStyle = {
position: 'relative',
width: 16,
height: 16,
verticalAlign: 'bottom',
};
export const subTextStyle = {
position: 'relative',
fontSize: '12px',
color: constants.colorMutedLight,
textOverflow: 'initial',
display: 'block',
marginTop: '1px',
};
// TODO - add in the relevant text invocations of TableHeroImage
export const isRadiant = playerSlot => playerSlot < 128;
export function pad(n, width, z = '0') {
const str = `${n}`;
return str.length >= width ? str : new Array((width - str.length) + 1).join(z) + n;
}
export function formatSeconds(input) {
if (!Number.isNaN(parseFloat(input)) && Number.isFinite(Number(input))) {
const absTime = Math.abs(input);
const minutes = Math.floor(absTime / 60);
const seconds = pad(Math.floor(absTime % 60), 2);
let time = ((input < 0) ? '-' : '');
time += `${minutes}:${seconds}`;
return time;
}
return null;
}
export function formatSkillOrAttributeValues(values) {
if (Array.isArray(values)) {
return values.filter(value => value).join(' / ');
}
return values;
}
export function getLevelFromXp(xp) {
for (let i = 0; i < xpLevel.length; i += 1) {
if (xpLevel[i] > xp) {
return i;
}
}
return xpLevel.length;
}
export const calculateDistance = (x1, y1, x2, y2) =>
(((x2 - x1) ** 2) + ((y2 - y1) ** 2)) ** 0.5;
export const calculateRelativeXY = ({ clientX, clientY, currentTarget }) => {
// const bounds = target.getBoundingClientRect();
// const x = clientX - bounds.left;
// const y = clientY - bounds.top;
let x = clientX + document.body.scrollLeft;
let y = clientY + document.body.scrollTop;
if (currentTarget.offsetParent) {
let off = currentTarget.offsetParent;
do {
x -= off.offsetLeft;
y -= off.offsetTop;
off = off.offsetParent;
} while (off);
}
return { x, y };
};
export const getPercentWin = (wins, games) => (games ? Number(((wins * 100) / games).toFixed(2)) : 0);
export const camelToSnake = str =>
str.replace(/\.?([A-Z]+)/g, (match, group) => `_${group.toLowerCase()}`).replace(/^_/, '');
export const getOrdinal = (n) => {
// TODO localize
const s = ['th', 'st', 'nd', 'rd'];
const v = n % 100;
return n + (s[(v - 20) % 10] || s[v] || s[0]);
};
export const jsonFn = json =>
arrayFn =>
fn =>
json[Object.keys(json)[arrayFn]((key, index) => fn(json[key], index))];
export const percentile = (pct) => {
if (pct >= 0.8) {
return {
color: 'green',
grade: 'A',
};
} else if (pct >= 0.6) {
return {
color: 'blue',
grade: 'B',
};
} else if (pct >= 0.4) {
return {
color: 'golden',
grade: 'C',
};
} else if (pct >= 0.2) {
return {
color: 'yelor',
grade: 'D',
};
}
return {
color: 'red',
grade: 'F',
};
};
export const IMAGESIZE_ENUM = {
SMALL: { // ~10KB
suffix: 'sb.png',
width: 59,
height: 33,
},
MEDIUM: { // ~41KB
suffix: 'lg.png',
width: 205,
height: 115,
},
LARGE: { // ~52KB
suffix: 'full.png',
width: 256,
height: 144,
},
VERT: { // ~18KB note that this is a jpg
suffix: 'vert.jpg',
width: 235,
height: 272,
},
// if you ever wanna see what the above look like (change the suffix):
// https://api.opendota.com/apps/dota2/images/dota_react/heroes/abaddon_full.png
};
const getTitle = (row, col, heroName) => {
if (row.match_id && row.player_slot !== undefined) {
return <TableLink to={`/matches/${row.match_id}`}>{heroName}</TableLink>;
}
return <TableLink to={`/heroes/${row[col.field]}`}>{heroName}</TableLink>;
};
export const getHeroImageUrl = (heroId, _) => {
const imageUrl = heroes[heroId] && config.VITE_IMAGE_CDN + heroes[heroId].img;
return imageUrl;
};
export const getHeroIconUrlFromHeroKey = (heroKey) => {
const heroId = Object.keys(heroes).find(k => heroes[k].name === heroKey);
if (heroId && heroId[0] && heroes[heroId[0]]) {
return `${config.VITE_IMAGE_CDN}${heroes[heroId].icon}`;
}
return '/assets/images/blank-1x1.gif';
};
// Fills in a template with the values provided in the dict
// returns a list, so react object don't have to be converted to a string
// Any keys not found in the given dictionary are simply left untouched
// If a non-object is passed in, a dict will automatically be created with args[1...len] to be used.
// brackets can be escaped with \
// Examples:
// formatTemplate("{person} name is {name}", { person: "My", name: "Gaben" });
// returns [ "My", " name is ", "Gaben" ]
// formatTemplate("{person} name is {name}", { name: <font color={styles.golden}>{"Gaben"}</font> });
// returns [ "{person} name is ", <font color={styles.golden}>{"Gaben"}</font> ]
export const formatTemplate = (template, dict, ...rest) => {
if (!template) {
return ['(invalid template)'];
}
let tmplValues = dict;
// If the 2nd argument isn't a dictionary, then we will gather arguments 1 => end into an object.
// I'm arbitrarily making argument 0 the template.
if ((dict instanceof Object) === false) {
tmplValues = Object.assign({}, [dict].concat(rest));
}
const pattern = /(\{[^}]+\})/g;
let result = template.split(pattern);
for (let i = 0; i < result.length; i += 1) {
if (result[i].match(pattern) && result[i].slice(1, -1) in tmplValues) {
result[i] = tmplValues[result[i].slice(1, -1)];
}
}
result = result.filter(part => part !== '');
return result;
};
export const formatTemplateToString = (template, dict, ...rest) => formatTemplate(template, dict, ...rest).join('');
export const defaultSort = (array, sortState, sortField, sortFn) =>
array.sort((a, b) => {
const sortFnExists = typeof sortFn === 'function';
const aVal = (sortFnExists ? sortFn(a) : a[sortField]) || 0;
const bVal = (sortFnExists ? sortFn(b) : b[sortField]) || 0;
const desc = aVal < bVal ? 1 : -1;
const asc = aVal < bVal ? -1 : 1;
return sortState === 'desc' ? desc : asc;
});
export const SORT_ENUM = {
0: 'desc',
1: 'asc',
asc: 1,
desc: 0,
next: state => SORT_ENUM[(state >= 1 ? 0 : state + 1)],
};
export function getObsWardsPlaced(pm) {
if (!pm.obs_log) {
return 0;
}
return pm.obs_log.filter(l => !l.entityleft).length;
}
export function isSupport(pm) {
return getObsWardsPlaced(pm) >= 2 && pm.lh_t && pm.lh_t[10] < 20;
}
export function isRoshHero(pm) {
const roshHeroes = {
npc_dota_hero_lycan: 1,
npc_dota_hero_ursa: 1,
npc_dota_hero_troll_warlord: 1,
};
return heroes[pm.hero_id] && (heroes[pm.hero_id].name in roshHeroes);
}
export function isActiveItem(key) {
const whitelist = {
branches: 1,
bloodstone: 1,
radiance: 1,
};
// TODO this will only work for english data files
return (items[key].active && !(key in whitelist));
}
export const sum = (a, b) => a + b;
export const extractTransitionClasses = _styles => name => ({
enter: _styles[`${name}-enter`],
enterActive: _styles[`${name}-enter-active`],
leave: _styles[`${name}-leave`],
leaveActive: _styles[`${name}-leave-active`],
appear: _styles[`${name}-appear`],
appearActive: _styles[`${name}-appear-active`],
});
export const gameCoordToUV = (x, y) => ({
x: Number(x) - 64,
y: 127 - (Number(y) - 64),
});
// TODO: refactor this to use gameCoordToUV
/**
* Unpacks position data from hash format to array format
* 64 is the offset of x and y values
* subtracting y from 127 inverts from bottom/left origin to top/left origin
* */
export function unpackPositionData(input) {
if (typeof input === 'object' && !Array.isArray(input)) {
const result = [];
Object.keys(input).forEach((x) => {
Object.keys(input[x]).forEach((y) => {
result.push({
...gameCoordToUV(x, y),
value: input[x][y],
});
});
});
return result;
}
return input;
}
export const threshold = curry((start, limits, values, value) => {
if (limits.length !== values.length) throw new Error('Limits must be the same as functions.');
const limitsWithStart = limits.slice(0);
limitsWithStart.unshift(start);
return findLast((v, i) => inRange(limitsWithStart[i], limitsWithStart[i + 1], value), values);
});
export const getTeamLogoUrl = (logoUrl) => {
if (!logoUrl) {
return '';
}
// Use proxy layer to serve team logos
if (logoUrl.indexOf('/ugc') !== -1) {
return `${config.VITE_API_HOST}${logoUrl.substr(logoUrl.indexOf('/ugc'))}`;
}
return logoUrl;
};
/**
* Converts an HSV color value to RGB. Conversion formula
* adapted from http://en.wikipedia.org/wiki/HSV_color_space.
* Assumes h, s, and v are contained in the set [0, 1] and
* returns r, g, and b in the set [0, 255].
*
* @param Number h The hue
* @param Number s The saturation
* @param Number v The value
* @return Array The RGB representation
*/
export const hsvToRgb = (h, s, v) => {
let r;
let g;
let b;
const i = Math.floor(h * 6);
const f = (h * 6) - i;
const p = v * (1 - s);
const q = v * (1 - (f * s));
const t = v * (1 - ((1 - f) * s));
switch (i % 6) {
case 0: r = v; g = t; b = p; break;
case 1: r = q; g = v; b = p; break;
case 2: r = p; g = v; b = t; break;
case 3: r = p; g = q; b = v; break;
case 4: r = t; g = p; b = v; break;
case 5: r = v; g = p; b = q; break;
default: r = v; g = t; b = p;
}
return [r * 255, g * 255, b * 255];
};
export const bindWidth = (width, maxWidth) => Math.min(width, maxWidth);
export const getHeroesById = () => {
const obj = {};
Object.keys(heroes).forEach((hero) => {
obj[heroes[hero].name] = heroes[hero];
});
return obj;
};
// https://www.evanmiller.org/how-not-to-sort-by-average-rating.html
export const wilsonScore = (up, down) => {
if (!up) return 0;
const n = up + down;
const z = 1.64485; // 1.0 = 85%, 1.6 = 95%
const phat = up / n;
return (
phat + ((z * z) / (2 * n)) - (z * Math.sqrt(((phat * (1 - phat)) + (z * z / (4 * n))) / n))
) / (
1 + (z * z / n)
);
};
export const groupBy = (xs, key) =>
xs.reduce((rv, x) => {
(rv[x[key]] = rv[x[key]] || []).push(x); // eslint-disable-line no-param-reassign
return rv;
}, {});
export function groupByArray(xs, key) {
return xs.reduce((rv, x) => {
const v = key instanceof Function ? key(x) : x[key];
const el = rv.find(r => r && r.key === v);
if (el) {
el.values.push(x);
} else {
rv.push({
key: v,
values: [x],
});
}
return rv;
}, []);
}
export const sumValues = f => Object.values(f).reduce((a, b) => a + b);
/* eslint-disable camelcase */
// https://dota2.gamepedia.com/Attributes
export function compileLevelOneStats(hero) {
if (!hero) {
return {};
}
const statsBonuses = {
str: {
attackDamage: 1,
armor: 0.16,
health: 22.5,
health_regen: 0.69,
mana: 12,
mana_regen: 1.8,
mr: 0.1,
move_speed: 0.05,
attack_speed: 1,
},
int: {
attackDamage: 1,
armor: 0.16,
health: 18,
health_regen: 0.55,
mana: 15,
mana_regen: 2.25,
mr: 0.08,
move_speed: 0.05,
attack_speed: 1,
},
agi: {
attackDamage: 1,
armor: 0.2,
health: 18,
health_regen: 0.55,
mana: 12,
mana_regen: 1.8,
mr: 0.08,
move_speed: 0.063,
attack_speed: 1.25,
},
all: {
attackDamage: 0.7,
armor: 0.2,
health: 18,
health_regen: 0.55,
mana: 12,
mana_regen: 1.8,
mr: 0.08,
move_speed: 0.063,
attack_speed: 1.25,
},
};
const round = value => Math.round(value * 100) / 100;
const {
primary_attr,
base_attack_max,
base_attack_min,
base_armor,
base_health,
base_health_regen,
base_mana,
base_mana_regen,
base_mr,
base_move_speed,
attack_rate,
} = hero;
const [agiValue, strValue, intValue] = [hero.base_agi, hero.base_str, hero.base_int];
const primaryAttrValue = primary_attr === "all" ? agiValue + strValue + intValue : hero[`base_${primary_attr}`]
return {
...hero,
base_attack_min: Math.round(base_attack_min + (statsBonuses[primary_attr].attackDamage * primaryAttrValue)),
base_attack_max: Math.round(base_attack_max + (statsBonuses[primary_attr].attackDamage * primaryAttrValue)),
base_armor: round(base_armor + (statsBonuses[primary_attr].armor * agiValue)),
base_health: round(base_health + (statsBonuses[primary_attr].health * strValue)),
base_health_regen: round(base_health_regen + (base_health_regen * (statsBonuses[primary_attr].health_regen * strValue / 100))),
base_mana: round(base_mana + (statsBonuses[primary_attr].mana * intValue)),
base_mana_regen: round(base_mana_regen + (base_mana_regen * (statsBonuses[primary_attr].mana_regen * intValue / 100))),
base_mr: round(base_mr + (base_mr * (statsBonuses[primary_attr].mr * strValue / 100))),
base_move_speed: round(base_move_speed + (base_move_speed * (statsBonuses[primary_attr].move_speed * agiValue / 100))),
attack_rate: round(1.7 / (attack_rate / (1 + ((statsBonuses[primary_attr].attack_speed * agiValue) / 100))) * 100), // ingame representation of attack speed
};
}
/* eslint-enable camelcase */
export const getTeamName = (team, _isRadiant) => {
const { strings } = store.getState().app;
if (_isRadiant) {
return (team && team.name) ? team.name : strings.general_radiant;
}
return (team && team.name) ? team.name : strings.general_dire;
};
export function abbreviateNumber(num) {
const { strings } = store.getState().app;
if (!num) {
return '-';
} else if (num >= 1000 && num < 1000000) {
return `${Number((num / 1000).toFixed(1))}k`;
} else if (num >= 1000000 && num < 1000000000) {
return `${Number((num / 1000000).toFixed(1))}${strings.abbr_million}`;
} else if (num >= 1000000000 && num < 1000000000000) {
return `${Number((num / 1000000000).toFixed(1))}${strings.abbr_billion}`;
} else if (num >= 1000000000000) {
return `${Number((num / 1000000000000).toFixed(1))}${strings.abbr_trillion}`;
}
return num.toFixed(0);
}
export function rankTierToString(rankTier) {
const { strings } = store.getState().app;
if (rankTier !== parseInt(rankTier, 10)) {
return strings.general_unknown;
}
const intRankTier = parseInt(rankTier, 10);
let rank = strings[`rank_tier_${parseInt(intRankTier / 10, 10)}`];
if (intRankTier > 9 && intRankTier !== 80) {
rank += ` [${parseInt(intRankTier % 10, 10)}]`;
}
return rank;
}
export function fromNow(time) {
const { strings } = store.getState().app;
const units = [{
name: strings.time_s,
plural: strings.time_ss,
limit: minute,
in_seconds: second,
}, {
name: strings.time_m,
plural: strings.time_mm,
limit: hour,
in_seconds: minute,
}, {
name: strings.time_h,
plural: strings.time_hh,
limit: day,
in_seconds: hour,
}, {
name: strings.time_d,
plural: strings.time_dd,
limit: month,
in_seconds: day,
}, {
name: strings.time_M,
plural: strings.time_MM,
limit: year,
in_seconds: month,
}, {
name: strings.time_y,
plural: strings.time_yy,
limit: null,
in_seconds: year,
}];
const diff = (new Date() - new Date(time * 1000)) / 1000;
if (diff < 5) {
return strings.time_just_now;
}
for (let i = 0; i < units.length; i += 1) {
const unit = units[i];
if (diff < unit.limit || !unit.limit) {
const val = Math.floor(diff / unit.in_seconds);
return formatTemplateToString(strings.time_past, val > 1 ? formatTemplateToString(unit.plural, val) : unit.name);
}
}
return '';
}
export function displayHeroId(row, col, field, showGuide = false, guideUrl, guideType) {
const { strings } = store.getState().app;
const heroId = row[col.field];
const heroName = heroes[row[col.field]] ? heroes[row[col.field]].localized_name : strings.general_no_hero;
const getSubtitle = (row) => {
if (row.match_id && row.player_slot !== undefined) {
let lane;
let tooltip;
if (row.is_roaming) {
tooltip = strings.roaming;
lane = 'roam';
} else {
tooltip = strings[`lane_role_${row.lane_role}`];
lane = row.lane_role;
}
const roleIconStyle = {
float: 'right',
marginTop: '2px',
height: '14px',
};
return (
<div>
{row && <span style={{ float: 'left' }}><FromNowTooltip timestamp={row.start_time + row.duration} /></span>}
{lane ?
<span data-hint={tooltip} data-hint-position="top" style={{ float: 'right' }}>
<img
src={`/assets/images/dota2/lane_${lane}.svg`}
alt=""
style={roleIconStyle}
/>
</span>
: ''}
</div>);
} else if (row.last_played) {
return <FromNowTooltip timestamp={row.last_played} />;
} else if (row.start_time) {
return <FromNowTooltip timestamp={row.start_time} />;
}
return null;
};
return (
<TableHeroImage
parsed={row.version}
heroID={heroId}
title={getTitle(row, col, heroName)}
subtitle={getSubtitle(row)}
heroName={heroName}
showGuide={showGuide}
guideUrl={guideUrl}
guideType={guideType}
leaverStatus={row.leaver_status}
hero={compileLevelOneStats(heroes[row.hero_id])}
/>
);
}
export function displayHeroIdWithPvgna(row, col, field) {
return displayHeroId(row, col, field, true, row.pvgnaGuide && row.pvgnaGuide.url, 'PVGNA');
}
export function displayHeroIdWithMoreMmr(row, col, field) {
let url = 'https://moremmr.com/en/heroes/';
if (heroes[row[col.field]] && heroes[row[col.field]].localized_name) {
const heroName = heroes[row[col.field]].localized_name.toLowerCase().replace(' ', '-');
url = `https://moremmr.com/en/heroes/${heroName}/videos?utm_source=opendota&utm_medium=heroes&utm_campaign=${heroName}`;
}
return displayHeroId(row, col, field, true, url, 'MOREMMR');
}
/**
* Transformations of table cell data to display values.
* These functions are intended to be used as the displayFn property in table columns.
* This is why they all take (row, col, field)
* */
// TODO - these more complicated ones should be factored out into components
export const transformations = {
match_id: (row, col, field) => <Link to={`/matches/${field}`}>{field}</Link>,
match_id_with_time: (row, col, field) => (
<div>
<TableLink to={`/matches/${field}`}>{field}</TableLink>
<span style={{ ...subTextStyle, display: 'block', marginTop: 1 }}>
{fromNow(row.start_time)}
</span>
</div>),
radiant_win_and_game_mode: (row, col, field) => {
const matchId = row.match_id;
const { strings } = store.getState().app;
const won = field === isRadiant(row.player_slot);
const getColor = (result) => {
if (result === null || result === undefined) {
return constants.colorMuted;
}
return won ? constants.colorGreen : constants.colorRed;
};
const getString = (result) => {
if (result === null || result === undefined) {
return strings.td_no_result;
}
return won ? strings.td_win : strings.td_loss;
};
const partyTextStyle = {
fontSize: '9px',
position: 'absolute',
lineHeight: '3px',
textAlign: 'center',
width: '100%',
fontFamily: 'Tahoma',
};
const partySize = (_partySize) => {
if (_partySize === 1) {
return <SocialPerson color="rgb(179, 179, 179)" style={{ ...iconStyle, float: 'right' }} />;
} else if (_partySize === null || _partySize === undefined) {
return null;
}
return (
<div style={{ float: 'right', marginTop: '-3px', marginRight: '2px' }}>
<SocialPeople color="rgb(179, 179, 179)" style={iconStyle} />
<div style={partyTextStyle}>{`x${row.party_size}`}</div>
</div>
);
};
const partyStyle = {
...subTextStyle,
float: 'right',
marginRight: '-14px',
};
const sameTeam = (_sameTeam) => {
if (_sameTeam == null) {
return null;
}
return (
<div>
{_sameTeam ? strings.th_with_games : strings.th_against_games}
</div>
);
};
return (
<div>
<TableLink to={`/matches/${matchId}`} color={getColor(field)}>
<span style={{ color: getColor(field) }}>
{getString(field)}
</span>
</TableLink>
<div>
<span style={{ ...subTextStyle, marginTop: 1, display: 'inline' }}>
{row.league_name ? row.league_name : strings[`lobby_type_${row.lobby_type}`]}
</span>
<span
style={partyStyle}
data-hint={`${strings.filter_party_size} ${row.party_size || strings.game_mode_0}`}
data-hint-position="top"
>
{partySize(row.party_size)}
</span>
<span>
{sameTeam(row.sameTeam)}
</span>
</div>
</div>);
},
mode: (row, col, field) => {
const { strings } = store.getState().app;
const skillStyle = {
...subTextStyle,
display: 'inline',
float: 'left',
opacity: `${!row.average_rank ? 0.6 : 1}`,
};
return (
<div>
{strings[`game_mode_${field}`] && (`${strings[`game_mode_${field}`]}`)}
<div style={{ display: 'flex', justifyContent: 'space-between' }}>
<span style={skillStyle}>
{rankTierToString(row.average_rank)}
</span>
</div>
<ReactTooltip place="top" effect="solid" />
</div>
);
},
start_time: (row, col, field) => <FromNowTooltip timestamp={field} />,
last_played: (row, col, field) => <FromNowTooltip timestamp={field} />,
duration: (row, col, field) => {
const { strings } = store.getState().app;
const playerSideExists = row && typeof row.player_slot !== 'undefined';
const playerIsRadiant = playerSideExists && isRadiant(row.player_slot);
const teamSideExists = row && typeof row.radiant !== 'undefined';
const teamIsRadiant = teamSideExists && row.radiant;
const displaySide = playerSideExists || teamSideExists;
return (
<div>
<span>
{formatSeconds(field)}
</span>
{displaySide && <span style={{ ...subTextStyle }}>{playerIsRadiant || teamIsRadiant ? strings.general_radiant : strings.general_dire}</span>}
</div>
);
},
patch: (row, col, field) => (patch[field] ? patch[field].name : field),
winPercent: (row, col, field) => `${(field * 100).toFixed(2)}%`,
kda: (row, col, field) => <KDA kills={field} deaths={row.deaths} assists={row.assists} />,
rank: (row, col, field) => getOrdinal(field),
rank_percentile: row => (
<span style={{ color: constants[percentile(row.rank / row.card).color] }}>
{getPercentWin(row.rank, row.card).toFixed(2)}%
</span>
),
player: row => (
<TableHeroImage
image={row.avatar || row.avatarfull}
title={row.name || row.personaname}
subtitle={row.subtitle || (row.last_played && <FromNowTooltip timestamp={row.last_played} />)}
registered={row.last_login}
confirmed={row.account_id && row.name}
contributor={row.is_contributor}
subscriber={row.is_subscriber}
accountId={row.account_id}
/>
),
};
/* ---------------------------- match item_n transformations ---------------------------- */
// This code is used to transform the items in the match.players (array of players with match data).
// the items for each player are stored as item_0, item_1, ..., item_5. If there is no item, we
// have a value of 0 there, so we return false for those cases so we don't render a broken image link.
// Otherwise, we just put the url in the image. THis will also contain the tooltip stuff as well
// (once I get to the tooltips).
const transformMatchItem = ({
field,
}) => {
if (field === 0) {
return false;
}
return `${config.VITE_IMAGE_CDN}${items[itemIds[field]].img}`;
};
for (let i = 0; i < 6; i += 1) {
transformations[`item_${i}`] = transformMatchItem;
}
export function isLeapYear(date) {
const year = date.getFullYear();
if ((year & 3) !== 0) { // eslint-disable-line no-bitwise
return false;
}
return ((year % 100) !== 0 || (year % 400) === 0);
}
// Get Day of Year
export function getDOY(date) {
const dayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
const mn = date.getMonth();
const dn = date.getDate();
let dayOfYear = dayCount[mn] + dn;
if (mn > 1 && isLeapYear(date)) {
dayOfYear += 1;
}
return dayOfYear;
}
// find and style/highlight number values in tooltip descriptions
export function styleValues(el, style = 'font-weight:500;color:#F5F5F5') {
if (el) {
const element = el;
element.innerHTML = el.innerHTML
.replace(/(,)(\d)/gm, ' / $2')
.replace(/\s?-?\s?\d+\.?%?\d*%?x?/gm, `<span style=${style}>$&</span>`);
}
return null;
}
export function formatValues(values) {
if (Array.isArray(values)) {
return values.filter(value => value).join(' / ');
}
return values;
}
// handles table cell custom and default styling
export function getColStyle(column) {
return {
textAlign: column.textAlign || 'initial',
paddingRight: column.paddingRight !== undefined ? column.paddingRight : 8,
paddingLeft: column.paddingLeft !== undefined ? column.paddingLeft : 8,
width: column.key === 'heroTd' && !column.width ? '1px' : column.width,
borderLeft: column.borderLeft,
borderRight: column.borderRight,
backgroundColor: column.colColor,
direction: column.textAlign === 'right' && 'rtl',
color: column.color || constants.secondaryTextColor,
};
}
export function getLocalizedWeekdayStrings() {
const langCode = window.localStorage.getItem('localization') || 'en-US';
const d = new Date();
return [...Array(7)].map((_, i) => new Date(d.setDate(d.getDate() - d.getDay() + i)).toLocaleDateString(langCode, { weekday: 'short' }));
}
export function getLocalizedMonthStrings() {
const langCode = window.localStorage.getItem('localization') || 'en-US';
const d = new Date();
return [...Array(12)].map((_, i) => new Date(d.setMonth(i)).toLocaleDateString(langCode, { month: 'short' }));
}
export function formatGraphValueData(data, histogramName) {
if (data !== 0 && !data) return '';
switch (histogramName) {
case 'duration':
return formatSeconds(data);
default:
return data;
}
}
export function escapeRegExp(stringToGoIntoTheRegex) {
return stringToGoIntoTheRegex.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); // eslint-disable-line no-useless-escape
}
/**
* Takes a string of URL query params, converts it into an object, and adds the turbo filter params if localstorage setting is set
* @param params A string of URL query params
*/
export function paramsWithTurbo(params) {
const isTurboMode = window.localStorage.getItem('modeFilter') === 'turbo';
let objParams = params ?? {};
if (typeof params === 'string' && params) {
objParams = querystring.parse(params.slice(1));
}
if (!isTurboMode) {
return objParams;
}
return { ...objParams, significant: 0, game_mode: 23 };
}
export const patchDate = {};
patch.forEach((patchElement) => {
patchDate[patchElement.name] = new Date(patchElement.date).getTime() / 1000;
});
export function getWardSize(type, mapSize) {
const originMapSize = 12000;
if (type === 'observer') {
return (mapSize * 1600) / originMapSize;
} else {
return (mapSize * 1000) / originMapSize;
}
};
| odota/web/src/utility/index.jsx/0 | {
"file_path": "odota/web/src/utility/index.jsx",
"repo_id": "odota",
"token_count": 11628
} | 278 |
[
{
"match_id": 1609407252,
"player_slot": 129,
"radiant_win": false,
"duration": 2402,
"game_mode": 1,
"lobby_type": 0,
"kills": 37,
"hero_id": 44,
"start_time": 1436112424,
"version": null,
"deaths": 4,
"assists": 12,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1885252612,
"player_slot": 2,
"radiant_win": true,
"duration": 2943,
"game_mode": 1,
"lobby_type": 0,
"kills": 37,
"hero_id": 56,
"start_time": 1445565709,
"version": null,
"deaths": 6,
"assists": 12,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 208998640,
"player_slot": 128,
"radiant_win": false,
"duration": 1734,
"game_mode": 1,
"lobby_type": 0,
"kills": 36,
"hero_id": 63,
"start_time": 1370099781,
"version": null,
"deaths": 3,
"assists": 11,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1374706868,
"player_slot": 131,
"radiant_win": false,
"duration": 2579,
"game_mode": 1,
"lobby_type": 0,
"kills": 36,
"hero_id": 17,
"start_time": 1428178769,
"version": null,
"deaths": 4,
"assists": 15,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 190396210,
"player_slot": 2,
"radiant_win": true,
"duration": 2792,
"game_mode": 1,
"lobby_type": 0,
"kills": 35,
"hero_id": 46,
"start_time": 1367947759,
"version": null,
"deaths": 4,
"assists": 10,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1362579704,
"player_slot": 129,
"radiant_win": true,
"duration": 3751,
"game_mode": 1,
"lobby_type": 0,
"kills": 35,
"hero_id": 11,
"start_time": 1427767414,
"version": null,
"deaths": 8,
"assists": 12,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 69864157,
"player_slot": 3,
"radiant_win": true,
"duration": 1811,
"game_mode": 1,
"lobby_type": 0,
"kills": 35,
"hero_id": 46,
"start_time": 1354200699,
"version": null,
"deaths": 0,
"assists": 10,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 2331124413,
"player_slot": 131,
"radiant_win": true,
"duration": 4209,
"game_mode": 3,
"lobby_type": 7,
"kills": 35,
"hero_id": 43,
"start_time": 1462037723,
"version": null,
"deaths": 5,
"assists": 29,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1235683281,
"player_slot": 3,
"radiant_win": true,
"duration": 1995,
"game_mode": 1,
"lobby_type": 0,
"kills": 35,
"hero_id": 44,
"start_time": 1423862756,
"version": null,
"deaths": 5,
"assists": 15,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 599735525,
"player_slot": 129,
"radiant_win": false,
"duration": 2508,
"game_mode": 1,
"lobby_type": 7,
"kills": 34,
"hero_id": 106,
"start_time": 1396906078,
"version": null,
"deaths": 8,
"assists": 20,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 164820537,
"player_slot": 0,
"radiant_win": true,
"duration": 2997,
"game_mode": 1,
"lobby_type": 0,
"kills": 32,
"hero_id": 17,
"start_time": 1365004227,
"version": null,
"deaths": 8,
"assists": 16,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 334645722,
"player_slot": 130,
"radiant_win": false,
"duration": 2415,
"game_mode": 1,
"lobby_type": 0,
"kills": 32,
"hero_id": 81,
"start_time": 1381006104,
"version": null,
"deaths": 8,
"assists": 21,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 2808259130,
"player_slot": 4,
"radiant_win": true,
"duration": 1786,
"game_mode": 1,
"lobby_type": 0,
"kills": 32,
"hero_id": 76,
"start_time": 1480288416,
"version": null,
"deaths": 5,
"assists": 10,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1519816717,
"player_slot": 129,
"radiant_win": false,
"duration": 3120,
"game_mode": 1,
"lobby_type": 0,
"kills": 32,
"hero_id": 62,
"start_time": 1433186032,
"version": null,
"deaths": 1,
"assists": 26,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1621192651,
"player_slot": 1,
"radiant_win": true,
"duration": 4212,
"game_mode": 1,
"lobby_type": 0,
"kills": 32,
"hero_id": 11,
"start_time": 1436524000,
"version": null,
"deaths": 14,
"assists": 10,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1852418923,
"player_slot": 129,
"radiant_win": false,
"duration": 2697,
"game_mode": 1,
"lobby_type": 0,
"kills": 31,
"hero_id": 44,
"start_time": 1444323867,
"version": null,
"deaths": 7,
"assists": 14,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 302229513,
"player_slot": 129,
"radiant_win": false,
"duration": 3202,
"game_mode": 1,
"lobby_type": 0,
"kills": 31,
"hero_id": 39,
"start_time": 1378603459,
"version": null,
"deaths": 6,
"assists": 14,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 147834612,
"player_slot": 1,
"radiant_win": true,
"duration": 2380,
"game_mode": 1,
"lobby_type": 0,
"kills": 30,
"hero_id": 46,
"start_time": 1363170052,
"version": null,
"deaths": 2,
"assists": 7,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1914250121,
"player_slot": 131,
"radiant_win": false,
"duration": 2106,
"game_mode": 22,
"lobby_type": 7,
"kills": 30,
"hero_id": 46,
"start_time": 1446655240,
"version": null,
"deaths": 2,
"assists": 8,
"skill": null,
"leaver_status": 0,
"party_size": null
},
{
"match_id": 1818767219,
"player_slot": 4,
"radiant_win": false,
"duration": 3393,
"game_mode": 1,
"lobby_type": 0,
"kills": 30,
"hero_id": 34,
"start_time": 1443190158,
"version": null,
"deaths": 8,
"assists": 11,
"skill": null,
"leaver_status": 0,
"party_size": null
}
] | odota/web/testcafe/cachedAjax/players_101695162_matches_sort=kills&limit=20.json/0 | {
"file_path": "odota/web/testcafe/cachedAjax/players_101695162_matches_sort=kills&limit=20.json",
"repo_id": "odota",
"token_count": 3131
} | 279 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.