text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> : []
})
<|fim_prefix|>import { createStore, createLogger } from 'vuex'
import * as getters from './getters'
import * as actions from './acti<|fim_middle|>ons'
import mutations from './mutations'
const state = {
currentThreadID: null,
threads: {
/*
id: {
id,
name,
messages:... | fim | vuejs/vuex | javascript |
<|fim_prefix|>export default {
receiveAll (state, messages) {
let latestMessage
messages.forEach(message => {
// create new thread if the thread doesn't exist
if (!state.threads[message.threadID]) {
<|fim_suffix|>hreads,
[id]: {
id,
name,
messages: [],
lastMessag... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { createApp } from 'vue'
import Counter fro<|fim_suffix|>eApp(Counter)
app.use(store)
app.mount('#app')
<|fim_middle|>m './Counter.vue'
import store from './store'
const app = creat<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { createStore } from 'vuex'
// root state object.
// each Vuex instance is just a single state tree.
const state = {
count: 0
}
// mutations are operations that actually mutate the state.
// each mutation handler gets the entire state tree as the
// first argument, followed by additional payloa... | fim | vuejs/vuex | javascript |
<|fim_suffix|>unterControls)
app.use(store)
app.mount('#app')
<|fim_prefix|>import { createApp } from 'vue'
import store from './store'
import CounterControls from './CounterControls.vue'
const app = creat<|fim_middle|>eApp(Co<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>t')
}
}
export const incrementAsync = ({ commit }) => {
setTimeout(() => {
commit('increment')
}, 1000)
}
<|fim_prefix|>export const increment = ({ commit }) => {
commit('increment')
}
export const decrement = ({ commit }) => {
commit('decrement')
}
export con<|fim_middle|>st incrementIfOd... | fim | vuejs/vuex | javascript |
<|fim_prefix|>export const count =<|fim_suffix|> .join(', ')
}
<|fim_middle|> state => state.count
export const recentHistory = state => {
return state.history
.slice(-5)
<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>({
state,
getters,
actions,
mutations
})
if (module.hot) {
module.hot.accept([
'./getters',
'./actions',
'./mutations'
], () => {
store.hotUpdate({
getters: require('./getters'),
actions: require('./actions'),
mutations: require('./mutations')
})
})
}
... | fim | vuejs/vuex | javascript |
<|fim_suffix|> state.history.push('decrement')
}
<|fim_prefix|>export const increment = state => {
state.count++
state.history.p<|fim_middle|>ush('increment')
}
export const decrement = state => {
state.count--
<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>r')
}
}
}
function wait (ms) {
return new Promise(resolve => {
setTimeout(resolve, ms)
})
}
<|fim_prefix|>/**
* Mocking client-server processing
*/
const _products = [
{ 'id': 1, 'title': 'iPad 4 Mini', 'price': 500.01, 'inventory': 2 },
{ 'id': 2, 'title': 'H&M T-Shirt White', 'price... | fim | vuejs/vuex | javascript |
<|fim_suffix|>t app = createApp(App)
app.use(store)
app.mount('#app')
<|fim_prefix|>import { createApp } from 'vue'
import App from './components/App.vue'
import st<|fim_middle|>ore from './store'
import { currency } from './currency'
cons<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|> _float
}
<|fim_prefix|>const digitsRE = /(\d{3})(?=\d)/g
export function currency (value, currency, decimals) {
value = parseFloat(value)
if (!isFinite(value) || (!value && value !== 0)) return ''
currency = currency != null ? currency : '$'
decimals = decimals != null ? decimals : 2
var st... | fim | vuejs/vuex | javascript |
import { createStore, createLogger } from 'vuex'
import cart from './modules/cart'
import products from './modules/products'
const debug = process.env.NODE_ENV !== 'production'
export default createStore({
modules: {
cart,
products
},
strict: debug,
plugins: debug ? [createLogger()] : []
})
<|endoftex... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import shop from '../../api/shop'
import nested from './nested'
// initial state
// shape: [{ id, quantity }]
const state = () => ({
items: [],
checkoutStatus: null
})
// getters
const getters = {
cartProducts: (state, getters, rootState) => {
return state.items.map(({ id, quantity }) => {
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>export default {
namespaced: true,
state: () => ({
foo: '<|fim_suffix|>: {
twoBars: state => state.foo.repeat(2)
}
}
<|fim_middle|>bar'
}),
getters<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>import shop from '../../api/shop'
// initial state
const state = () => ({
all: []
})
// getters
const getters = {}
// actions
const actions = {
async getAllProducts ({ commit }) {
const p<|fim_suffix|> }
}
// mutations
const mutations = {
setProducts (state, products) {
state.all = produ... | fim | vuejs/vuex | javascript |
import { createApp } from 'vue'
import store from './store'
import App from './components/App.vue'
const app = createApp(App)
app.use(store)
app.mount('#app')
<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>state, commit }) {
state.todos.filter(todo => todo.done)
.forEach(todo => {
commit('removeTodo', todo)
})
}
}
<|fim_prefix|>export default <|fim_middle|>{
addTodo ({ commit }, text) {
commit('addTodo', {
text,
done: false
})
},
removeTodo ({ commit }, t... | fim | vuejs/vuex | javascript |
import { createStore } from 'vuex'
import { mutations, STORAGE_KEY } from './mutations'
import actions from './actions'
import plugins from './plugins'
export default createStore({
state: {
todos: JSON.parse(window.localStorage.getItem(STORAGE_KEY) || '[]')
},
actions,
mutations,
plugins
})
<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>tate.todos.indexOf(todo)
state.todos.splice(index, 1, {
...todo,
text,
done
})
}
}
<|fim_prefix|>export const STORAGE_KEY = 'todos-vuejs'
// for <|fim_middle|>testing
if (navigator.webdriver) {
window.localStorage.clear()
}
export const mutations = {
addTodo (state, todo... | fim | vuejs/vuex | javascript |
import { createLogger } from 'vuex'
import { STORAGE_KEY } from './mutations'
const localStoragePlugin = store => {
store.subscribe((mutation, { todos }) => {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(todos))
})
}
export default process.env.NODE_ENV !== 'production'
? [createLogger(), localSto... | fim | vuejs/vuex | javascript |
<|fim_suffix|>
cb(message)
}, LATENCY)
}
<|fim_prefix|>c<|fim_middle|>onst data = require('./mock-data')
const LATENCY = 16
export function getAllMessages (cb) {
setTimeout(() => {
cb(data)
}, LATENCY)
}
export function createMessage ({ text, thread }, cb) {
const timestamp = Date.now()
const id = '... | fim | vuejs/vuex | javascript |
<|fim_prefix|>module.exports = [
{
id: 'm_1',
threadID: 't_1',
threadName: 'Jing and Bill',
authorName: 'Bill',
text: 'Hey Jing, want to give a Flux talk at ForwardJS?',
timestamp: Date.now() - 99999
},
{
id: 'm_2',
threadID: 't_1',
threadName: 'Jing and Bill',
authorName: ... | fim | vuejs/vuex | javascript |
<|fim_suffix|>rt { getAllMessages } from './store/actions'
const app = createApp(App)
app.use(store)
app.mount('#app')
getAllMessages(store)
<|fim_prefix|>import { createApp } from '<|fim_middle|>vue'
import App from './components/App.vue'
import store from './store'
impo<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>}, payload) => {
api.createMessage(payload, message => {
commit('receiveMessage', message)
})
}
export const switchThread = ({ commit }, payload) => {
commit('switchThread', payload)
}
<|fim_prefix|>import *<|fim_middle|> as api from '../api'
export const getAllMessages = ({ commit }) => {
a... | fim | vuejs/vuex | javascript |
<|fim_prefix|>export const threads = state => st<|fim_suffix|>tThread = state => {
return state.currentThreadID
? state.threads[state.currentThreadID]
: {}
}
export const currentMessages = state => {
const thread = currentThread(state)
return thread.messages
? thread.messages.map(id => state.messages... | fim | vuejs/vuex | javascript |
<|fim_suffix|> text,
timestamp,
isRead
}
*/
}
}
export default createStore({
state,
getters,
actions,
mutations,
plugins: process.env.NODE_ENV !== 'production'
? [createLogger()]
: []
})
<|fim_prefix|>import { createStore, createLogger } from 'vuex'
import * as getters from ... | fim | vuejs/vuex | javascript |
<|fim_suffix|>{
state.currentThreadID = id
if (!state.threads[id]) {
debugger
}
// mark thread as read
state.threads[id].lastMessage.isRead = true
}
<|fim_prefix|>export default {
receiveAll (state, messages) {
let latestMessage
messages.forEach(message => {
// create new thread if the thr... | fim | vuejs/vuex | javascript |
<|fim_suffix|>re from './store'
const app = createApp(Counter)
app.use(store)
app.mount('#app')
<|fim_prefix|>import { createApp } from 'vue'
import Counter<|fim_middle|> from './Counter.vue'
import sto<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|><|fim_suffix|>are functions.
const getters = {
evenOrOdd: state => state.count % 2 === 0 ? 'even' : 'odd'
}
// A Vuex instance is created by combining the state, mutations, actions,
// and getters.
export default createStore({
state,
getters,
actions,
mutations
})
<|fim_middle|>import { createS... | fim | vuejs/vuex | javascript |
<|fim_suffix|>CounterControls.vue'
const app = createApp(CounterControls)
app.use(store)
app.mount('#app')
<|fim_prefix|>import { createApp } from 'vue'
import store from './stor<|fim_middle|>e'
import CounterControls from './<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>export const increment = ({ commit }) => {
commit('increment')
}
export const decrement = ({ commit }) => {
commit('decrement')
}
export const incrementIfOdd = ({ commit, state }) => {
if ((state.count + 1) % 2 === 0) {
commit('increment')
}
}
<|fim_suffix|>nst incrementAsync = ({ commit }) ... | fim | vuejs/vuex | javascript |
<|fim_suffix|>port const recentHistory = state => {
const end = state.history.length
const begin = end - limit < 0 ? 0 : end - limit
return state.history
.slice(begin, end)
.join(', ')
}
<|fim_prefix|>export const count = state => state.count
export const t = (state) => {
retu<|fim_middle|>rn state.tes... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { createStore } from 'vuex'
import * as getters from './getters'
import * as actions from './actions'
import * as mutations from './mutations'
const state = {
test: 0,
count: 0,
history: []
}
const store = createStore({
state,
getters,
actions,
mutations
})
if (module.hot) {
<|fim_... | fim | vuejs/vuex | javascript |
<|fim_prefix|>export cons<|fim_suffix|>ate => {
state.count++
state.history.push('increment')
}
export const decrement = state => {
state.count--
state.history.push('decrement')
}
<|fim_middle|>t increment = st<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>/**
* Mocking client-server processing
*/
const _<|fim_suffix|>ducts = [
{ 'id': 1, 'title': 'iPad 4 Mini', 'price': 500.01, 'inventory': 2 },
{ 'id': 2, 'title': 'H&M T-Shirt White', 'price': 10.99, 'inventory': 10 },
{ 'id': 3, 'title': 'Charli XCX - Sucker CD', 'price': 19.99, 'inventory': 5 }
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { createApp } from 'vue'
import App f<|fim_suffix|>
app.mount('#app')
<|fim_middle|>rom './components/App.vue'
import store from './store'
const app = createApp(App)
app.use(store)<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_suffix|>))
: ''
var _float = decimals
? stringified.slice(-1 - decimals)
: ''
var sign = value < 0 ? '-' : ''
return sign + currency + head +
_int.slice(i).replace(digitsRE, '$1,') +
_float
}
<|fim_prefix|>const digitsRE = /(\d{3})(?=\d)/g
export function currency (value, currency, deci... | fim | vuejs/vuex | javascript |
<|fim_suffix|>ort default createStore({
modules: {
cart,
products
},
strict: debug,
plugins: debug ? [createLogger()] : []
})
<|fim_prefix|>import { createStore, createLogger } from 'vue<|fim_middle|>x'
import cart from './modules/cart'
import products from './modules/products'
const debug = process.en... | fim | vuejs/vuex | javascript |
<|fim_suffix|>product = rootState.products.all.find(product => product.id === id)
return {
id: product.id,
title: product.title,
price: product.price,
quantity
}
})
},
cartTotalPrice: (state, getters) => {
return getters.cartProducts.reduce((total, product) => {
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import shop from '../../api/shop'
// initial state
const state = {
all: []
}
// getters
const getters = {}
// actions
const actions = {
getAllProducts ({ commit }) {
shop.getProducts(products => {
commit('setProducts', products)
})
}
}
// mutations
const mutations = {
<|fim_suffix... | fim | vuejs/vuex | javascript |
<|fim_suffix|>nst app = createApp(App)
app.use(store)
app.mount('#app')
<|fim_prefix|><|fim_middle|>import { createApp } from 'vue'
import store from './store'
import App from './components/App.vue'
co<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>export default {
addTodo ({ commit }, text) {
commit('addTodo', {
text,
done: false
})
},
removeTodo ({ commit }, todo) {
commit('removeTodo', <|fim_suffix|>todo => todo.done)
.forEach(todo => {
commit('removeTodo', todo)
})
}
}
<|fim_middle|>todo)
},... | fim | vuejs/vuex | javascript |
import { createStore } from 'vuex'
import { mutations, STORAGE_KEY } from './mutations'
import actions from './actions'
import plugins from './plugins'
export default createStore({
state: {
todos: JSON.parse(window.localStorage.getItem(STORAGE_KEY) || '[]')
},
actions,
mutations,
plugins
})
<|endoftext|> | fim | vuejs/vuex | javascript |
export const STORAGE_KEY = 'todos-vuejs'
// for testing
if (navigator.webdriver) {
window.localStorage.clear()
}
export const mutations = {
addTodo (state, todo) {
state.todos.push(todo)
},
removeTodo (state, todo) {
state.todos.splice(state.todos.indexOf(todo), 1)
},
editTodo (state, { todo, te... | fim | vuejs/vuex | javascript |
<|fim_suffix|>e.subscribe((mutation, { todos }) => {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(todos))
})
}
export default process.env.NODE_ENV !== 'production'
? [createLogger(), localStoragePlugin]
: [localStoragePlugin]
<|fim_prefix|>import { createLogger } from 'vuex'
import { STORAGE_KEY }... | fim | vuejs/vuex | javascript |
<|fim_suffix|>calhost:${port}, Ctrl+C to stop`)
})
<|fim_prefix|>const express = require('express')
const webpack = require('webpack')
const webpackDevMiddleware = require('webpack-dev-middleware')
const webpackHotMiddleware = require('webpack-hot-middleware')
const WebpackConfig =<|fim_middle|> require('./webpack.conf... | fim | vuejs/vuex | javascript |
<|fim_suffix|>},
resolve: {
alias: {
vuex: path.resolve(__dirname, '../src/index.js')
}
},
optimization: {
splitChunks: {
cacheGroups: {
vendors: {
name: 'shared',
filename: 'shared.js',
chunks: 'initial'
}
}
}
},
plugins: [
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>module.exports = {
<|fim_suffix|>/$1',
'^test/(.*)$': '<rootDir>/test/$1'
},
testMatch: ['<rootDir>/test/**/*.spec.js'],
testPathIgnorePatterns: ['/node_modules/'],
setupFilesAfterEnv: ['./test/setup.js'],
transform: {
'^.+\\.js$': '<rootDir>/node_modules/babel-jest'
},
coverageDirec... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import buble from '@rollup/plugin-buble'
import replace from '@rollup/plugin-replace'
import resolve from '@rollup/plugin-node-resolve'
import commonjs from '@rollup/plugin-commonjs'
import { terser } from 'rollup-plugin-terser'
import pkg from './package.json'
const banner = `/*!
* vuex v${pkg.version}... | fim | vuejs/vuex | javascript |
const fs = require('fs-extra')
const chalk = require('chalk')
const execa = require('execa')
const { gzipSync } = require('zlib')
const { compress } = require('brotli')
const files = [
'dist/vuex.esm-browser.js',
'dist/vuex.esm-browser.prod.js',
'dist/vuex.esm-bundler.js',
'dist/vuex.global.js',
'dist/vuex.g... | fim | vuejs/vuex | javascript |
<|fim_prefix|>const fs = require('fs')
const path = require('path')
const chalk = require('chalk')
const semver = require('semver')
const { prompt } = require('enquirer')
const execa = require('execa')
const currentVersion = require('../package.json').version
const versionIncrements = [
'patch',
'minor',
'major'... | fim | vuejs/vuex | javascript |
import { isObject } from './util'
/**
* Reduce the code which written in Vue.js for getting the state.
* @param {String} [namespace] - Module's namespace
* @param {Object|Array} states # Object's item can be a function which accept state and getters for param, you can do something for state and getters in it.
* @p... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { Store, createStore } from './store'
import { storeKey, useStore } from './injectKey'
import { mapState,<|fim_suffix|>rt default {
version: '__VERSION__',
Store,
storeKey,
createStore,
useStore,
mapState,
mapMutations,
mapGetters,
mapActions,
createNamespacedHelpers,
createLo... | fim | vuejs/vuex | javascript |
<|fim_suffix|>acedHelpers,
createLogger
}
<|fim_prefix|>import { Store, createStore } from './store'
import { storeKey, useStore } from './injectKey'
import { mapState, mapMutations, mapGetters, mapActions, createNamespacedHelpers } from './helpers'
import { createLogger } from './plugins/logger'
export default {
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import Vuex from '../dist/vuex.cjs.js'
const {
version,
Store,
storeKey,
createStore,
install,
useStore,
mapState,
mapMutations,
mapGetters,
m<|fim_suffix|>dHelpers,
createLogger
} = Vuex
export {
Vuex as default,
version,
Store,
storeKey,
createStore,
install,
useSto... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { inject } from 'vue'
export const storeKey = 'store'
e<|fim_suffix|>? key : storeKey)
}
<|fim_middle|>xport function useStore (key = null) {
return inject(key !== null <|endoftext|> | fim | vuejs/vuex | javascript |
import Module from './module'
import { assert, forEachValue } from '../util'
export default class ModuleCollection {
constructor (rawRootModule) {
// register root module (Vuex.Store options)
this.register([], rawRootModule, false)
}
get (path) {
return path.reduce((module, key) => {
return mo... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { forEachValue } from '../util'
// Base data struct for store's module, package with some attribute and method
export default class Module {
constructor (rawModule, runtime) {
this.runtime = runtime
// Store some children item
this._children = Object.create(null)
// Store the ori... | fim | vuejs/vuex | javascript |
<|fim_suffix|>= action.payload
}
data.state = state
api.addTimelineEvent({
layerId: ACTIONS_LAYER_ID,
event: {
time: Date.now(),
title: action.type,
groupId: action._id,
subtitle: 'end',
data
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>// Credits: borrowed code from fcomb/redux-logger
import { deepCopy } from '../util'
export function createLogger ({
collapsed = true,
filter = (mutation, stateBefore, stateAfter) => true,
transformer = state => state,
mutationTransformer = mut => mut,
actionFilter = (action, state) => true,
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { reactive, computed, watch, effectScope } from 'vue'
import { forEachValue, isObject, isPromise, assert, partial } from './util'
export function genericSubscribe (fn, subs, options) {
if (subs.indexOf(fn) < 0) {
options && options.prepend
? subs.unshift(fn)
: subs.push(fn)
}
... | fim | vuejs/vuex | javascript |
import { watch } from 'vue'
import { storeKey } from './injectKey'
import { addDevtools } from './plugins/devtool'
import ModuleCollection from './module/module-collection'
import { assert } from './util'
import {
genericSubscribe,
getNestedState,
installModule,
resetStore,
resetStoreState,
unifyObjectStyle... | fim | vuejs/vuex | javascript |
<|fim_suffix|>= Array.isArray(obj) ? [] : {}
// put the copy into cache at first
// because we want to refer it in recursive deepCopy
cache.push({
original: obj,
copy
})
Object.keys(obj).forEach(key => {
copy[key] = deepCopy(obj[key], cache)
})
return copy
}
/**
* forEach for object
*/
ex... | fim | vuejs/vuex | javascript |
<|fim_suffix|>in('Total: $1,000.02')
expect(await count('li:nth-child(1) button[disabled]')).toBe(1)
await click('li:nth-child(2) button')
expect(await text('.cart')).toContain('H&M T-Shirt White - $10.99 x 1')
expect(await text('.cart')).toContain('Total: $1,011.01')
await click('.cart button')
... | fim | vuejs/vuex | javascript |
<|fim_suffix|>).toContain('Unread threads: 2')
expect(await count('.thread-list-item')).toBe(3)
expect(await text('.thread-list-item.active')).toContain('Functional Heads')
expect(await text('.message-thread-heading')).toContain('Functional Heads')
expect(await count('.message-list-item')).toBe(2)
e... | fim | vuejs/vuex | javascript |
<|fim_suffix|> await click('button:nth-child(4)')
expect(await text('#app')).toContain('Clicked: 2 times')
await sleep(1000)
expect(await text('#app')).toContain('Clicked: 3 times')
}
test('classic', async () => {
await testCounter('http://localhost:8080/classic/counter/')
}, E2E_TIMEOUT)
tes... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { setupPuppeteer, E2E_TIMEOUT } from 'test/helpers'
describe('e2e/todomvc', () => {
const {
page,
isVisible,
isChecked,
isFocused,
text,
value,
count,
hasClass,
hover,
click,
keyUp,
setValue,
enterValue,
clearValue
} = setupPuppeteer()
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import assert from 'assert'
import { createRequire } from 'module'
import Vuex, {
Store,
install,
version,
mapState,
mapMutations,
mapGetters,
mapActions,
createNamespacedHelpers,
createLogger
} from 'vuex'
const require = createRequire(import.meta.url)
const cjs = require('vuex')
a... | fim | vuejs/vuex | javascript |
// only test esm entry points on Node.14 or higher
const [major] = process.versions.node.split('.')
if (+major >= 14) {
(async function () {
await import('./esm-import.mjs')
})().catch(console.error)
}
<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { createApp } from 'vue'
import puppeteer from 'puppeteer'
export function mount (store, component) {
const el = createElement()
component.render = component.render || (() => {})
const app = createApp(component)
app.use(store)
return app.mount(el)
}
function createElement () {
con... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import <|fim_suffix|>ator-runtime/runtime'
<|fim_middle|>'regener<|endoftext|> | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { mount } from 'test/helpers'
import Vuex, { mapState, mapMutations, mapGetters, mapActions, createNamespacedHelpers } from '@/index'
describe('Helpers', () => {
it('mapState (array)', () => {
const store = new Vuex.Store({
state: {
a: 1
}
})
const vm = mount(stor... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { nextTick } from 'vue'
import { mount } from 'test/helpers'
import Vuex from '@/index'
const TEST = 'TEST'
const isSSR = process.env.VUE_ENV === 'server'
describe('Hot Reload', () => {
it('mutations', function () {
const mutations = {
[TEST] (state, n) {
state.a += n
}
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import ModuleCollection from '@/module/module-collection'
describe('ModuleCollection', () => {
it('get', () => {
const collection = new ModuleCollection({
state: { value: 1 },
modules: {
a: {
state: { value: 2 }
},
b<|fim_suffix|>({})
collection.unr... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import Module from '@/module/module'
describe('Module', () => {
it('get state', () => {
const module = new Module({
state: {
value: true
}
})
expect(module.state).toEqual({ value: true })
})
it('get state: should return object if state option is empty', () => {
... | fim | vuejs/vuex | javascript |
<|fim_suffix|>ion', function () {
let calls = 0
const makeAction = n => {
return {
[TEST] ({ state, rootState }) {
calls++
expect(state.a).toBe(n)
expect(rootState).toBe(store.state)
}
}
}
const store = new Vuex.Store({
... | fim | vuejs/vuex | javascript |
<|fim_suffix|> commit(TEST, n)
}
}
})
store.dispatch(TEST, 2)
expect(store.state.a).toBe(3)
})
it('dispatching with object style', () => {
const store = new Vuex.Store({
state: {
a: 1
},
mutations: {
[TEST] (state, n) {
state.a += n
... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { find, deepCopy, forEachValue, isObject, isPromise, assert } from '@/util'
describe('util', () => {
it('find: returns item when it was found', () => {
const list = [33, 22, 112, 222, 43]
expect(find(list, function (a) { return a % 2 === 0 })).toEqual(22)
})
it('find: returns undefi... | fim | vuejs/vuex | javascript |
<|fim_prefix|>import { ComponentPublicInstance } from 'vue';
import { Dispatch, Commit } from './index';
type Computed = () => any;
type InlineComputed<T extends Function> = T extends (...args: any[]) => infer R ? () => R : never
type MutationMethod = (...args: any[]) => void;
type ActionMethod = (...args: any[]) => P... | fim | vuejs/vuex | typescript |
<|fim_suffix|>Key<Store<S>> | string): Store<S>;
export interface Dispatch {
(type: string, payload?: any, options?: DispatchOptions): Promise<any>;
<P extends Payload>(payloadWithType: P, options?: DispatchOptions): Promise<any>;
}
export interface Commit {
(type: string, payload?: any, options?: CommitOptions... | fim | vuejs/vuex | typescript |
import { Payload, Plugin } from "./index";
interface Logger extends Partial<Pick<Console, 'groupCollapsed' | 'group' | 'groupEnd'>> {
log(message: string, color: string, payload: any): void;
log(message: string): void;
}
export interface LoggerOption<S> {
collapsed?: boolean;
filter?: <P extends Payload>(muta... | fim | vuejs/vuex | typescript |
<|fim_prefix|>import { createApp } from "vue";
import {
mapState,
mapGetters,
mapActions,
mapMutations,
createNamespacedHelpers
} from "../index";
const helpers = createNamespacedHelpers('foo');
createApp({
computed: {
...mapState(["a"]),
...mapState('foo', ["b"]),
...mapState({
c: "c"
... | fim | vuejs/vuex | typescript |
<|fim_suffix|> actions: {
foo ({ state, getters, dispatch, commit }, payload) {
this.state.value;
state.value;
getters.count;
dispatch("bar", {});
commit("bar", {});
}
},
mutations: {
bar (state, payload) {}
},
strict: true,
devtools: true
... | fim | vuejs/vuex | typescript |
<|fim_suffix|>w Vuex.Store({
state: {
value: 1
}
});
const app = createApp({
store
});
<|fim_prefix|>import { createApp } from "vue";
i<|fim_middle|>mport * as Vuex from "../index";
const store = ne<|endoftext|> | fim | vuejs/vuex | typescript |
<|fim_prefix|>/**
* Extends<|fim_suffix|>e "@vue/runtime-core" {
interface ComponentCustomOptions {
store?: Store<any>;
}
}
<|fim_middle|> interfaces in Vue.js
*/
import { ComponentCustomOptions } from "vue";
import { Store } from "./index";
declare modul<|endoftext|> | fim | vuejs/vuex | typescript |
<|fim_prefix|>import path from 'path'
import versions from './versions'
const latest = versions[0]
const nav = [
{
text: '首页',
link: '/'
},
{
text: '文档',
activeMatch: `^/([0-9]\.x)/`,
items: versions.map((version) => ({
text: version,
link: `/${version}/`
}))
},
{
tex... | fim | w7corp/easywechat | typescript |
<|fim_prefix|>import './styles/index.css'
import { h, App } from 'vue'
import SponsorsAside from './components/SponsorsAside.vue'
import VersionTag from './components/VersionTag.vue'
import Footer from './components/Footer.vue'
<|fim_suffix|> // @ts-ignore
return h(DefaultTheme.Layout, null, {
// banner: () =... | fim | w7corp/easywechat | typescript |
<|fim_suffix|>, "4.x", "3.x"];
<|fim_prefix|>export default ["<|fim_middle|>6.x", "5.x"<|endoftext|> | fim | w7corp/easywechat | typescript |
<|fim_suffix|>onfig' {
import { UserConfig } from 'vitepress'
const config: () => Promise<UserConfig>
export default config
}
declare module '@overtrue/easywechat-theme/highlight' {
const createHighlighter: () => Promise<(input: string) => string>
export default createHighlighter
}
<|fim_prefix|>/// <referen... | fim | w7corp/easywechat | typescript |
<|fim_prefix|>module.exports = {
plugins: [
require('postcss-import'),
require("tailwindcss")("./tail<|fim_suffix|>postcss-nested')
]
}<|fim_middle|>wind.config.js"),
require("autoprefixer"),
require('<|endoftext|> | fim | w7corp/easywechat | javascript |
<|fim_prefix|>exports = module.exports = [
{
text: '开始使用',
items: [
{ text: '概述', link: '/3.x/overview.html' },
{ text: '安装', link: '/3.x/installation.html' },
{ text: '小教程', link: '/3.x/tutorial.html' },
{ text: '配置', link: '/3.x/configuration.html' },
{ text: '在框架中使用', link: '/... | fim | w7corp/easywechat | javascript |
<|fim_prefix|>exports = module.exports = [
{
text: '开始使用',
collapsible: true,
items: [
{ text: '概述', link: '/4.x/overview.html' },
{ text: '安装', link: '/4.x/installation.html' },
{ text: '在框架中使用', link: '/4.x/integration.html' },
{ text: '常见问题汇总', link: '/4.x/troubleshooting.html' ... | fim | w7corp/easywechat | javascript |
<|fim_prefix|>exports = module.exports = [
{
text: '开始使用',
collapsible: true,
items: [
{ text: '概述', link: '/5.x/overview.html' },
{ text: '安装', link: '/5.x/installation.html' },
{ text: '在框架中使用', link: '/5.x/integration.html' },
{ text: '常见问题汇总', link: '/5.x/troubleshooting.html' ... | fim | w7corp/easywechat | javascript |
<|fim_suffix|> { text: '文件上传', link: '/6.x/pay/media.html' },
{ text: '代码示例', link: '/6.x/pay/examples.html' }
]
},
{
text: '小程序',
collapsible: true,
items: [
{ text: '入门', link: '/6.x/mini-app/index.html' },
{ text: 'API 调用', link: '/6.x/client.html' },
{ text: '配置', link... | fim | w7corp/easywechat | javascript |
<|fim_prefix|>module.exports = {
darkMode: 'class',
theme: {
extend: {}
},
variants: {},
plugins: [],
content: [
'./src/**/*.md',
'./.vitepress/theme/components/*.vue',
'./.vi<|fim_suffix|>theme/styles/*.scss',
],
}
<|fim_middle|>tepress/<|endoftext|> | fim | w7corp/easywechat | javascript |
<|fim_prefix|><?php
declare(strict_types=1);
namespace EasyWeChat\Kernel;
use ArrayAccess;
use EasyWeChat\Kernel\Contracts\Config as ConfigInterface;
use EasyWeChat\Kernel\Exceptions\InvalidArgumentException;
use EasyWeChat\Kernel\Support\Arr<|fim_suffix|> */
#[Pure]
public function get(array|string $key, m... | fim | w7corp/easywechat | php |
<?php
declare(strict_types=1);
namespace EasyWeChat\Kernel\Contracts;
interface AccessToken
{
public function getToken(): string;
/**
* @return array<string,string>
*/
public function toQuery(): array;
}
<|endoftext|> | fim | w7corp/easywechat | php |
<|fim_prefix|><?php
declare(strict_types=1);
<|fim_suffix|>ace EasyWeChat\Kernel\Contracts;
use EasyWeChat\Kernel\Contracts\AccessToken as AccessTokenInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
interface AccessTokenAwareHttpClient extends HttpClientInterface
{
public function withAccessToke... | fim | w7corp/easywechat | php |
<|fim_suffix|>ll): string;
public static function decrypt(string $ciphertext, string $key, ?string $iv = null): string;
}
<|fim_prefix|><?php
namespace EasyWeChat\Kernel\Contracts;
interface Aes
{
public static function encrypt(string $plaintext, string $key, ?string $iv =<|fim_middle|> nu<|endoftext|> | fim | w7corp/easywechat | php |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.