text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>import Vue from 'vue'
const vm = new Vue({
data: {
documentVisible: !document.hidden,
documentFocus: document.hasFocus()
}
})
document.addEventListener('visibilitychange', () => {
vm.documentVisible = !document.hidden
}, false)
<|fim_suffix|>window.addEventListener('blur', () => {
vm.doc... | fim | vuejs/vue-cli | javascript |
import PROGRESS from '@/graphql/progress/progress.gql'
import PROGRESS_CHANGED from '@/graphql/progress/progressChanged.gql'
import PROGRESS_REMOVED from '@/graphql/progress/progressRemoved.gql'
// @vue/component
export default {
props: {
progressId: {
type: String,
required: true
}
},
data ... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> }
return this[field].prompts.filter(
p => p.visible
)
}
},
watch: {
hasPromptsChanged: {
handler (value) {
this.$emit('has-changes', value)
},
immediate: true
}
},
methods: {
async answerPrompt ({ ... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>export default function ({
gridSize,
field,
zoom
}) {
// @vue/component
return {
data () {
return {
resizeState: null
}
},
computed: {
showResizeHandle () {
return this.isSelected && !this.moveState &&
this.canBeResized
},
can... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>},
mounted () {
setTimeout(() => {
this.$_restoreRouteReady = true
}, 100)
},
methods: {
replaceBaseRoute () {
if (baseRoute && !isSameRoute(this.$route, baseRoute, false)) {
this.$router.replace(baseRoute)
}
}
}
}
}
<|fim_prefi... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import Vue from 'vue'
import VueUi from '@vue/ui'
import InstantSearch from 'vue-instantsearch'
import VueMeta from 'vue-meta'
import PortalVue from 'portal-vue'
import VueObserveVisibility from 'vue-observe-visibility'
import * as Filters from './filters'
import Responsive from './util/responsive'
import... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>/**
* We register all the components so future cli-ui plugins
* could use them directly
*/
import Vue from 'vue'
// https://webpack.js.org/guides/dependency-management/#require-context
const requireComponent = require.context('./components', true, /[a-z0-9]+\.(jsx?|vue)$/i)
// For each matching file... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> }
})
}
}
next()
})
export default router
<|fim_prefix|>import Vue from 'vue'
import Router from 'vue-router'
import { apolloClient } from './vue-apollo'
import ProjectHome from './components/app/ProjectHome.vue'
import ProjectDashboard from './components/dashboard/ProjectDashboard.v... | fim | vuejs/vue-cli | javascript |
export default () => ({
connected: true,
loading: 0,
darkMode: false,
currentProjectId: null
})
<|endoftext|> | fim | vuejs/vue-cli | javascript |
import LOADING from '@/graphql/loading/loading.gql'
export default {
Mutation: {
connectedSet: (root, { value }, { cache }) => {
const data = {
connected: value
}
cache.writeData({ data })
return null
},
loadingChange: (root, { mod }, { cache }) => {
const { loading... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import gql from 'graphql-tag'
export default gql`
extend type Query {
connected: Boolean!
loading: Boolean!
darkMode: Boolean!
currentProjectId: String
}
extend type Mutation {
connectedSe<|fim_suffix|>mod: Int!): Boolean
darkModeSet (enabled: Boolean!): Boolean
currentProjectIdSet (projec... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>listeners)
}
listeners.push(cb)
}
awaitComponent (id) {
return new Promise((resolve, reject) => {
const result = this.getComponent(id)
if (result) {
resolve(result)
} else {
this.listenForComponent(id, resolve)
}
})
}
}
export function toComp... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> ansiUp = new AU()
ansiUp.use_classes = true
ansiUp.escape_for_html = false
export default {
install (Vue) {
Vue.prototype.ansiColors = text => ansiUp.ansi_to_html(text)
}
}
<|fim_prefix|>import AU from 'ansi_up'
cons<|fim_middle|>t<|endoftext|> | fim | vuejs/vue-cli | javascript |
import Vue from 'vue'
const bus = new Vue()
export default {
install (Vue) {
Vue.prototype.$bus = (type, ...args) => {
bus.$emit(type, ...args)
}
Vue.mixin({
beforeCreate () {
const busOptions = this.$options.bus
if (busOptions) {
this.$_bus = []
const a... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> const input = el.querySelector('input')
if (input) el = input
el.focus()
})
}
}
<|fim_prefix|>export default {
bind (el) {
<|fim_middle|> requestAnimationFrame(() => {
<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>export function isValidName (name) {
return !name.match(/[/@\s+%:]|^[_.]/) && encodeURIComponent(<|fim_suffix|>function isValidMultiName (name) {
name = name.replace(/\\/g, '/')
return name.split('/').every(isValidName)
}
<|fim_middle|>name) === name && name.length <= 214
}
export <|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>export function getImageUrl (url) {
// Fix images in development
if (process.env.VUE_APP_CLI_UI_DEV && url.charAt(0) === '/') <|fim_suffix|>p://localhost:${process.env.VUE_APP_GRAPHQL_PORT}${url}`
}
return url
}
<|fim_middle|>{
return `htt<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import PLUGIN_ACTION_CALL from '@/graphql/plugin/pluginActionCall.gql'
import PLUGIN_ACTION_CALLED from '@/graphql/plugin/pluginActionCalled.gql'
import PLUGIN_ACTION_RESOLVED from '@/graphql/plugin/pluginActionResolved.gql'
let uid = 0
export default {
install (Vue) {
Vue.mixin({
methods: {... | fim | vuejs/vue-cli | javascript |
export let responsive
export default {
install (Vue, options) {
const finalOptions = Object.assign({}, {
computed: {}
}, options)
responsive = new Vue({
data () {
return {
width: window.innerWidth,
height: window.innerHeight
}
},
computed: fina... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>urrent)) {
return false
}
}
return true
}
<|fim_prefix|>const trailingSlashRE = /\/?$/
export function isSameRoute (a, b, checkQuery = true) {
if (!b) {
return false
} else if (a.path && b.path) {
return (
a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlas... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>export function generateSearchRegex (text) {
return<|fim_suffix|>), 'i')
}
<|fim_middle|> text && new RegExp(text.trim().replace(/\s+/g, '.{0,5}'<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> el.style.height = `${bounds.height}px`
})
}
}
<|fim_prefix|>export default {
bind (el, { value }) {
if (typeof va<|fim_middle|>lue === 'string') {
value = el.querySelector(value)
}
requestAnimationFrame(() => {
const bounds = value.getBoundingClientRect()
el.styl... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import SHARED_DATA from '@/graphql/shared-data/sharedData.gql'
import SHARED_DATA_UPDATE from '@/graphql/shared-data/sharedDataUpdate.gql'
import SHARED_DATA_UPDATED from '@/graph<|fim_suffix|>d = await this.$getProjectId()
const smartQueries = []
for (const key in options) {
... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>let forcedTheme = null
{
const result = /\?theme=(\w+)/.exec(window.lo<|fim_suffix|>cedTheme
}
<|fim_middle|>cation.href)
if (result) forcedTheme = result[1]
}
console.log('forced theme', forcedTheme)
export function getForcedTheme () {
return for<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>d', () => setConnected(true))
wsClient.on('reconnected', async () => {
await resetApollo()
setConnected(true)
})
// Offline
wsClient.on('disconnected', () => setConnected(false))
wsClient.on('error', () => setConnected(false))
/* Dark mode */
function loadDarkMode () {
let enabled, forcedTheme
i... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> 'tests/e2e/support/index.js',
execTimeout: 1000000,
pageLoadTimeout: 1000000,
requestTimeout: 1000000,
responseTimeout: 1000000,
env: {
cwd: path.resolve(__dirname, '../../../../../test')
}
})
}
<|fim_prefix|>// https://docs.cypress.io/guides/guides/plugins-guide.html
cons... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>describe('Vue project man<|fim_suffix|>tton"]').click()
cy.get('.cta-text.favorite').should('be.visible')
cy.get('.project-select-list-item').eq(0).get('[data-testid="favorite-button"]').click()
cy.get('.cta-text.favorite').should('not.exist')
})
it('Imports a project', () => {
cy.vie... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>('not.have.class', 'disabled')
.click()
cy.get('.project-plugin-item').should('have.length', 6)
})
})
<|fim_prefix|>describe('Plugins', () => {
it('Should display the plugins', () => {
cy.visit('/plugins')
cy.get('.project-plugin-item').should('have.length', 5)
})
it('Should add... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>
})
<|fim_prefix|>describe('Configurations', () => {
it('Displays configurations', () => {
cy.visit('/configuration')
cy.get('.configuration-item').should('hav<|fim_middle|>e.length', 3)
})<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> })
})
<|fim_prefix|>describe('Tasks', () => {
it('Displays tasks', () => {
cy.visit('/tasks')
cy.get('.<|fim_middle|>task-item:contains("serve")').should('be.visible')
cy.get('.task-item:contains("build")').should('be.visible')
cy.get('.task-item:contains("lint")').should('be.visible')
... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>********
//
//
// -- This is a parent command --
// Cypress.Commands.add("login", (email, password) => { ... })
//
//
// -- This is a child command --
// Cypress.Commands.add("drag", { prevSubject: 'element'}, (subject, options) => { ... })
//
//
// -- This is a dual command --
// Cypress.Commands.add("di... | fim | vuejs/vue-cli | javascript |
// ***********************************************************
// This example support/index.js is processed and
// loaded automatically before your test files.
//
// This is a great place to put global configuration and
// behavior that modifies Cypress.
//
// You can change the location of this file or turn off
// au... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>module.exports = api => {
api.describeConfig({
id: 'org.vue.vue-cli',
name: 'Vue CLI',
description: 'org.vue.vue-webpack.config.vue-cli.description',
link: 'https://cli.vuejs.org/config/',
files: {
vue: {
js: ['vue.config.js']
}
},
icon: '/public/vue-cli.p... | fim | vuejs/vue-cli | javascript |
module.exports = api => {
require('./tasks')(api)
require('./suggestions')(api)
require('./config')(api)
require('./widgets')(api)
}
<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> } else {
// FIXME: a temporary fix for adding router plugin
// should implement a plugin prompt ui later
await add(id, { $inlineOptions: '{}' }, context)
}
} catch (e) {
error = e
}
api.removeProgress()
if (error) throw error
}
<|fim_prefix|>const { semver, loadModu... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>> {
api.ipcOff(onWebpackMessage)
},
...views
})
// vue inspect
api.addTask({
name: 'inspect',
command: 'vue-cli-service inspect',
description: 'org.vue.vue-webpack.tasks.inspect.description',
link: 'https://cli.vuejs.org/guide/webpack.html#inspecting-the-project-s-webpa... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>message
},
details: null
}
}
}
<|fim_prefix|>const { hasProjectYarn, hasProjectPnpm, execa } = require('@vue/cli-shared-utils')
const severity = {
critical: 0,
high: 1,
moderate: 2,
low: 3
}
exports.auditProject = async function (cwd) {
try {
if (hasProjectYarn(cwd)) {
... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>const getModulePath = function (identifier) {
return identifier.replace(/.*!/, '').replace(/\\/g, '/')
}
exports.filterModules = function (modules) {
return modules.filter(module => module.name.indexOf('(webpack)') === -1)
}
exports.buildSortedModules = function (modules, sizeField) {
let lis<|fim... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>const ModulesUtils = require('./modules')
const sizeTypes = ['stats', 'parsed', 'gzip']
exports.processSt<|fim_suffix|>dulesPerSizeType = {}
const analyzer = {}
for (const sizeType of sizeTypes) {
const modules = ModulesUtils.buildSortedModules(rawModules, sizeType)
const modulesTotalSize = ... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>rams => {
if (!parser) {
const Parser = require('rss-parser')
parser = new Parser()
}
if (!params.force) {
const cached = newsCache[params.url]
if (cached) return cached
}
let url = params.url
// GitHub repo
if (url.match(/^[\w_.-]+\/[\w_.-]+$/)) {
... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>// This file will be loaded when the project is opened
module.exports = api => {
if (!process.env.VUE_APP_CLI_UI_DEV) return
console.log('has(eslint)', api.hasPlugin('eslint'))
console.log('h<|fim_suffix|> value (for example a setting)
api.onProjectOpen(() => {
api.setSharedData('test-data', ... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>module.exports = {
pluginOptions: {
apollo: {
enableMocks: false,
enableEngine: false,
lintGQL: false
}
},
configureWebpack: {
resolve: {
symlinks: false
}
},
css: {
loaderOptions: {
stylus: {
sty<|fim_suffix|>orts']
}
}
... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>e: false,
name: 'off'
},
parserOptions: {
parser: '@babel/eslint-parser',
babelOptions: {
cwd: __dirname
}
},
rules: {
'vue/multi-word-component-names': 'warn'
}
}
<|fim_prefix|>module.exports = {
root: true,
extends: [
'plugin:vue/essential',
'@vue/standard... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>module.exports = {
prese<|fim_suffix|>'@vue/cli-plugin-babel/preset']
}
<|fim_middle|>ts: [<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> precision = 1
}
}
return (size / denominator.value).toFixed(precision) + denominator.label + unit
}
export function round (value, precision) {
return Math.round(value * precision) / precision
}
<|fim_prefix|>export function size (size, unit = '', precision = 1) {
const kb = {
label: ... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>e = key.match(/([a-z0-9]+)\./i)[1]
ClientAddonApi.addLocalization(locale, locales(key))
})
<|fim_prefix|>import VueProgress from 'vue-progress-path'
import WebpackDashboard from './components/W<|fim_middle|>ebpackDashboard.vue'
import WebpackAnalyzer from './components/WebpackAnalyzer.vue'
import TestVi... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>ild = value
},
immediate: true
}
},
created () {
const mode = this.mode = this.TaskDetails.task.command.match(/vue-cli-service\s+(\S+)/)[1]
this.$store.commit('mode', mode)
if (mode === 'build') {
this.syncMode('build-modern')
}
this.syncMode(mode)
},
me... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import Vuex from 'vuex'
import { buildSortedAssets } from '../util/assets'
Vue.use(Vuex)
const store = new Vuex.Store({
state () {
return {
sizeField: localStorage.getItem('org.vue.vue-webpack.sizeField') || 'parsed',
mode: 'serve',
showModernBuild: true,
serve: {
... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> ...speedsData[key]
}
return obj
}, {})
}
export function buildSortedAssets (assets, sizeField) {
let list = assets.slice()
if (list.length) {
const max = list[0].size
list = list.map(asset => {
const size = asset.size[sizeField]
return {
name: asset.name,
... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|> '#026A7E'
],
[
'#778F9B',
'#6D828D',
'#62767F',
'#576971',
'#4C5C63',
'#414E55'
]
]
}
<|fim_prefix|>export default {
light: [
[
'#42b983',
'#5DC395',
'#78CDA7',
'#93D7B9',
'#AEE1CB',
'#C9EBDD'
],
[
... | fim | vuejs/vue-cli | javascript |
const { clientAddonConfig } = require('@vue/cli-ui')
module.exports = {
...clientAddonConfig({
id: 'org.vue.webpack.client-addon',
port: 8096
})
}
<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>module.exports = {
root: true,
env: {
node: true
},
extends: [
'plugin:vue/essential',
<|fim_suffix|> : 'off',
'vue/multi-word-component-names': 'warn'
},
parserOptions: {
parser: '@babel/eslint-parser',
babelOptions: {
cwd: __dirname
}
},
globals: {
Clie... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>-babel/preset']
}
<|fim_prefix|>module.exports = {
pr<|fim_middle|>esets: ['@vue/cli-plugin<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>import Welcome from './components/Welcome.vue'
import KillPort from './components/KillPort.vue'
import PluginUpdates from './components/PluginUpdates.vue'
import DependencyUpdates from './components/DependencyUpdates.vue'
import Vulnerability from './components/Vulnerability.vue'
import VulnerabilityDetai... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>export const UPDATES_ICONS = {
ok: 'check_circle',
loading<|fim_suffix|>ccess',
loading: '',
attention: 'warning'
}
<|fim_middle|>: 'hourglass_full',
attention: 'error'
}
export const UPDATES_ICON_CLASSES = {
ok: 'su<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>ports = {
...clientAddonConfig({
id: 'org.vue.webpack.client-addon',
port: 8097
})
}
<|fim_prefix|>const { clientAd<|fim_middle|>donConfig } = require('@vue/cli-ui')
module.ex<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>// create package.json and README for packages that don't have one ye<|fim_suffix|>th = require('path')
const baseVersion = require('../packages/@vue/cli-service/package.json').version
const packagesDir = path.resolve(__dirname, '../packages/@vue')
const files = fs.readdirSync(packagesDir)
files.forEach... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>// Generate editorconfig templates from built-in eslint configs.
// Supported rules:
// indent_style
// indent_size
// end_of_line
// trim_trailing_whitespace
// insert_final_newline
// max_line_length
const fs = require('fs')
const path = require('path')
const ESLint = require('eslint').ESLint
// Conv... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>require('events').defaultMaxListeners = 0
const path = require('path')
const fs = require('fs')
const fetch = require('node-fetch')
const promises = []
async function checkLink (file, link, n) {
try {
const result = await fetch(link, { method: 'HEAD' })
i<|fim_suffix|>f (all) {
checkLink... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>const fs = require('fs')
const path = require('path')
const execa = require('execa')
async function genNewRelease () {
if (process.env.GIT_E2E_SETUP) {
return 'skipped for e2e testing'
}
const nextVersion = require('../lerna.json').version
const { stdout } = await execa(require.resolve('lern... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>const fs = require('fs')
const path = require('path')
const pluginsDirPath = path.resolve(__dirname, '../packages', '@vue')
const pluginRegEx = new RegExp('cli-plugin-')
function generatePluginDoc (plugin) {
const entryPath = path.resolve(__dirname, '../packages', '@vue', plugin, 'README.md')
const ... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>// Appveyor current only ships Chrome 72
// which is no longer supported by the latest version of Chromedriver.
const fs = require('fs')
const path = require('path')
const pkg = require('../package.json')
const versionS<|fim_suffix|>e="C:\\\\Program Files (x86)\\\\Google\\\\Chrome\\\\Application\\\\chro... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>/**
How to do a release:
1. Make sure you have publish access for all packages:
- You must be in the CLI team in the npm @vue organization
- You must have publish access to vue-cli-version-marker
- Make sure you DO NOT have npm per-publish 2-factor / OTP enabled, as it
does not work wi... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>/* eslint-disable */
// make sure generators are using the latest version of plugins,
// and plugins are using the latest version of deps
const fs = require('fs<|fim_suffix|>
}
})
if (!Object.keys(writeCache).length) {
return console.log(`All packages up-to-date.`)
}
if (skipPrompt)... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>const minimist = require('minimist')
const rawArgs = pr<|fim_suffix|>lugin|MochaPlugin|eslint8'
if (args['e2e-only']) {
regex = e2ePathPattern
const i = rawArgs.indexOf('--e2e-only')
rawArgs.splice(i, 2)
}
const jestArgs = [
'--env', 'node',
'--runInBand',
...rawArgs,
...(regex ? [regex] :... | fim | vuejs/vue-cli | javascript |
<|fim_prefix|>process.env.VUE_CLI_TEST = true
process.env<|fim_suffix|>IP_DIRTY_GIT_PROMPT = true
<|fim_middle|>.VUE_CLI_SK<|endoftext|> | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>k.green(`fix(v-model): handle events on blur (close #28)`)}\n\n` +
chalk.red(` See .github/COMMIT_CONVENTION.md for more details.\n`) +
chalk.red(` You can also use ${chalk.cyan(`npm run commit`)} to interactively generate a commit message.\n`)
)
process.exit(1)
}
<|fim_prefix|>const chalk =... | fim | vuejs/vue-cli | javascript |
<|fim_suffix|>
text.innerHTML = 'mutations : ' + (mutationsValue * 100).toFixed(0) + '%';
text.id = "ratioval";
slider.setAttribute("type", "range");
slider.style.cssText = 'margin-bottom: 10px; margin-top: 5px';
slider.addEventListener('change', function(e) {
ENV.mutations(e.target.value / 100);
docu... | fim | vuejs/vue | javascript |
var app = new Vue({
el: '#app',
data: {
databases: []
}
})
function loadSamples() {
app.databases = Object.freeze(ENV.generateData().toArray());
Monitoring.renderRate.ping();
setTimeout(loadSamples, ENV.timeout);
}
loadSamples()
<|endoftext|> | fim | vuejs/vue | javascript |
<|fim_prefix|>/**
* @author mrdoob / http://mrdoob.com/
* @author jetienne / http://jetienne.com/
* @author paulirish / http://paulirish.com/
*/
var MemoryStats = function (){
var msMin = 100;
var msMax = 0;
var container = document.createElement( 'div' );
container.id = 'stats';
container.style.cssText = 'w... | fim | vuejs/vue | javascript |
<|fim_suffix|>erRate
};
})();
<|fim_prefix|>var Monitoring = Monitoring || (function() {
var stats = new MemoryStats();
stats.domElement.style.position = 'fixed';
stats.domElement.style.right = '0px';
stats.domElement.style.bottom = '0px';
document.body.appendChild( stats.domElement );
re... | fim | vuejs/vue | javascript |
<|fim_suffix|>row.items" :key="item.id"></column></tr>',
components: {
column: {
template: '<td class="item">' +
// 25 plain elements for each cell
'<ul class="yoyo">' +
`<li v-for="i in 5" :class="'hihi' + i">` +
... | fim | vuejs/vue | javascript |
<|fim_suffix|>2)}ms`)
console.log(`complete: ${complete.toFixed(2)}ms`)
console.log()
})
<|fim_prefix|>/* eslint-disable no-unused-vars */
'use strict'
process.env.NODE_ENV = 'production'
const Vue = require('../../dist/vue.runtime.common.js')
const createRenderer = require('../../packages/server-renderer').crea... | fim | vuejs/vue | javascript |
<|fim_suffix|>rr) throw err
// console.log(res)
console.log('Complete time: ' + (self.performance.now() - self.s).toFixed(2) + 'ms')
console.log()
})
<|fim_prefix|>'use strict'
process.env.NODE_ENV = 'production'
const Vue = require('../../dist/vue.runtime.common.js')
const createRenderer = require('../../packa... | fim | vuejs/vue | javascript |
<|fim_suffix|>@vue/compiler-sfc'
<|fim_prefix|>e<|fim_middle|>xport * from '<|endoftext|> | fim | vuejs/vue | typescript |
<|fim_prefix|>module.exports = require('@vue/co<|fim_suffix|><|fim_middle|>mpiler-sfc')
<|endoftext|> | fim | vuejs/vue | javascript |
<|fim_prefix|>export * fro<|fim_suffix|>e/compiler-sfc'
<|fim_middle|>m '@vu<|endoftext|> | fim | vuejs/vue | javascript |
<|fim_prefix|>var apiURL = 'https://api.github.com/repos/vuejs/vue/commits?per_page=3&sha='
/**
* Actual demo
*/
new Vue({
el: '#demo',
data: {
branches: ['main', 'dev'],
currentBranch: 'main',
commits: null
},
created: function () {
this.fetchData()
},
watch: {
currentBranch: 'fe... | fim | vuejs/vue | javascript |
<|fim_prefix|>var emailRE = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
// Setup Firebase
var config = {
apiKey: "AIzaSyAi_yuJciPXLFr_PYPeU3eTvtXf8jbJ8zw",
authDomain: "vue-demo-537e6.firebaseapp.com<|fi... | fim | vuejs/vue | javascript |
<|fim_suffix|>
},
computed: {
filteredData: function () {
var sortKey = this.sortKey
var filterKey = this.filterKey && this.filterKey.toLowerCase()
var order = this.sortOrders[sortKey] || 1
var data = this.data
if (filterKey) {
data = data.filter(function (row) {
... | fim | vuejs/vue | javascript |
<|fim_prefix|>// The raw data to observe
var globalStats = [
{ label: 'A', value: 100 },
{ label: 'B', value: 100 },
{ label: 'C', value: 100 },
{ label: 'D', value: 100 },
{ label: 'E', value: 100 },
{ label: 'F', value: 100 }
]
// A reusable polygon graph component
Vue.component('polygraph', {
props: [... | fim | vuejs/vue | javascript |
<|fim_prefix|>// Full spec-compliant TodoMVC with localStorage persistence
// and hash-based routing in ~150 lines.
// localStorage persistence
var STORAGE_KEY = 'todos-vuejs-2.0'
var todoStorage = {
fetch: function () {
var todos = JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]')
todos.forEach(function... | fim | vuejs/vue | javascript |
<|fim_prefix|>// demo data
var data = {
name: 'My Tree',
children: [
{ nam<|fim_suffix|> }
},
methods: {
toggle: function () {
if (this.isFolder) {
this.open = !this.open
}
},
changeType: function () {
if (!this.isFolder) {
Vue.set(this.model, 'children', [])
... | fim | vuejs/vue | javascript |
// https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts
// should only use types from @babel/types
// do not import runtime methods
import type {
Identifier,
Node,
Function,
ObjectProperty,
BlockStatement,
Program
} from '@babel/types'
import { walk } from 'estree-walker'
expor... | fim | vuejs/vue | typescript |
import MagicString from 'magic-string'
import LRU from 'lru-cache'
import { walkIdentifiers, isFunctionType } from './babelUtils'
import { BindingMetadata, BindingTypes } from './types'
import { SFCDescriptor, SFCScriptBlock } from './parseComponent'
import {
parse as _parse,
parseExpression,
ParserOptions,
Par... | fim | vuejs/vue | typescript |
<|fim_suffix|>(
{
filename: options.filename
},
options.preprocessOptions
)
)
}
<|fim_prefix|>const postc<|fim_middle|>ss = require('postcss')
import { ProcessOptions, LazyResult } from 'postcss'
import trimPlugin from './stylePlugins/trim'
import scopedPlugin from './stylePlugins/scoped... | fim | vuejs/vue | typescript |
import { BindingMetadata, TemplateCompiler } from './types'
import assetUrlsModule, {
AssetURLOptions,
TransformAssetUrlsOptions
} from './templateCompilerModules/assetUrl'
import srcsetModule from './templateCompilerModules/srcset'
import consolidate from '@vue/consolidate'
import * as _compiler from 'web/entry-co... | fim | vuejs/vue | typescript |
<|fim_prefix|>import { BindingMetadata } from './types'
import { SFCDescriptor } from './parseComponent'
import { PluginCreator } from 'postcss'
import hash from 'hash-sum'
import { prefixIdentifiers } from './prefixIdentifiers'
export const CSS_VARS_HELPER = `useCssVars`
export function genCssVarsFromList(
vars: s... | fim | vuejs/vue | typescript |
<|fim_suffix|>ons,
SFCTemplateCompileResults
} from './compileTemplate'
export { SFCStyleCompileOptions, SFCStyleCompileResults } from './compileStyle'
export { SFCScriptCompileOptions } from './compileScript'
<|fim_prefix|>// API
export { parse } from './parse'
export { compileTemplate } from './compileTemplate'
exp... | fim | vuejs/vue | typescript |
<|fim_prefix|>import { SourceMapGenerator } from 'source-map'
import { RawSourceMap, TemplateCompiler } from './types'
import {
parseComponent,
VueTemplateCompilerParseOptions,
SFCDescriptor,
DEFAULT_FILENAME
} from './parseComponent'
import hash from 'hash-sum'
import LRU from 'lru-cache'
import { hmrShouldRe... | fim | vuejs/vue | typescript |
<|fim_suffix|>
}
}
}
function end(tag: string, start: number) {
if (depth === 1 && currentBlock) {
currentBlock.end = start
let text = source.slice(currentBlock.start, currentBlock.end)
if (
options.deindent === true ||
// by default, deindent unless it's script with... | fim | vuejs/vue | typescript |
<|fim_prefix|>import MagicString from 'magic-string'
import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
import { makeMap } from 'shared/util'
import { isStaticProperty, walkIdentifiers } from './babelUtils'
import { BindingMetadata } from './types'
const doNotPrefix = makeMap(
'Infinity,und... | fim | vuejs/vue | typescript |
<|fim_suffix|> boolean {
return defaultExportRE.test(input) || namedDefaultExportRE.test(input)
}
function specifierEnd(
input: string,
end: number,
nodeEnd: number | undefined | null
) {
// export { default , foo } ...
let hasCommas = false
let oldEnd = end
while (end < nodeEnd!) {
if (/\s/.test... | fim | vuejs/vue | typescript |
<|fim_prefix|>import { PluginCreator, Rule, AtRule } from 'postcss'
import selectorParser from 'postcss-selector-parser'
const animationNameRE = /^(-\w+-)?animation-name$/
const animationRE = /^(-\w+-)?animation$/
const scopedPlugin: PluginCreator<string> = (id = '') => {
const keyframes = Object.create(null)
con... | fim | vuejs/vue | typescript |
<|fim_prefix|>import { PluginCreator } from 'postcss'
const trimPlugin: PluginCreator<{}> = () => {
return {
postcssPlugin: 'vue-sfc-trim',
Onc<|fim_suffix|>aws }) => {
if (type === 'rule' || type === 'atrule') {
if (raws.before) raws.before = '\n'
if ('after' in raws && raws.afte... | fim | vuejs/vue | typescript |
<|fim_suffix|>
if (map) {
return {
code: result.css.toString(),
map: merge(map, JSON.parse(result.map.toString())),
errors: [],
dependencies
}
}
return { code: result.css.toString(), errors: [], dependencies }
} catch (e: any) {
return { code: '', errors: [... | fim | vuejs/vue | typescript |
<|fim_suffix|>name: string,
transformAssetUrlsOption?: TransformAssetUrlsOptions
) {
if (attr.name === name) {
const value = attr.value
// only transform static URLs
if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
attr.value = urlToRequire(value.slice(1, -1), transformAsse... | fim | vuejs/vue | typescript |
<|fim_prefix|>// vue compiler module for transforming `img:srcset` to a number of `require`s
import { urlToRequire } from './utils'
import { TransformAssetUrlsOptions } from './assetUrl'
import { ASTNode } from 'types/compiler'
interface ImageCandidate {
<|fim_suffix|> !node.attrs) {
return
}
if (node.tag ... | fim | vuejs/vue | typescript |
import { TransformAssetUrlsOptions } from './assetUrl'
import { UrlWithStringQuery, parse as uriParse } from 'url'
import path from 'path'
export function urlToRequire(
url: string,
transformAssetUrlsOption: TransformAssetUrlsOptions = {}
): string {
const returnValue = `"${url}"`
// same logic as in transform... | fim | vuejs/vue | typescript |
import { CompilerOptions, CompiledResult } from 'types/compiler'
import { SFCDescriptor } from './parseComponent'
export interface StartOfSourceMap {
file?: string
sourceRoot?: string
}
export interface RawSourceMap extends StartOfSourceMap {
version: string
sources: string[]
names: string[]
sourcesConten... | fim | vuejs/vue | typescript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.