any>> {
11 | (
12 | mutation: P,
13 | payload: StoreParameter,
14 | options?: CommitOptions
15 | ): ReturnType
16 | (
17 | mutation: StoreParameter extends never ? P : never,
18 | options?: CommitOptions
19 | ): ReturnType
20 | }
21 |
22 | export const mutationTree = <
23 | S extends Record,
24 | T extends MutationTree>
25 | >(
26 | _state: S,
27 | tree: T
28 | ) => tree
29 |
--------------------------------------------------------------------------------
/packages/typed-vuex/src/types/state.ts:
--------------------------------------------------------------------------------
1 | import { Not } from './utilities'
2 |
3 | type StateObject = Not, Function>
4 | type StateFunction = Not<() => unknown | any, Record>
5 |
6 | export type State = StateObject | StateFunction
7 | export type StateType = T extends () => any ? ReturnType : T
8 |
--------------------------------------------------------------------------------
/packages/typed-vuex/src/types/store.ts:
--------------------------------------------------------------------------------
1 | import { Store } from 'vuex'
2 | import { State, StateType } from './state'
3 | import { GettersTransformer } from './getters'
4 | import { MutationsTransformer } from './mutations'
5 | import {
6 | ActionTransformer,
7 | ActionContext,
8 | RootStateHelper,
9 | RootGettersHelper,
10 | } from './actions'
11 | import { NuxtModules, ModuleTransformer } from './modules'
12 |
13 | export interface BlankStore {
14 | state: {}
15 | getters: {}
16 | mutations: {}
17 | actions: {}
18 | modules: {}
19 | namespaced: boolean
20 | strict: boolean
21 | }
22 |
23 | export interface NuxtStore {
24 | state: State
25 | getters: Record
26 | mutations: Record
27 | actions: Record
28 | modules: NuxtModules
29 | namespaced: boolean
30 | strict: boolean
31 | }
32 |
33 | export interface NuxtStoreInput<
34 | T extends State,
35 | G,
36 | M,
37 | A,
38 | S extends { [key: string]: Partial }
39 | > {
40 | strict?: boolean
41 | namespaced?: boolean
42 | state: T
43 | getters?: G
44 | mutations?: M
45 | actions?: A
46 | modules?: S
47 | }
48 |
49 | export type MergedStoreType<
50 | T extends NuxtStore,
51 | K = string
52 | > = ('state' extends K ? StateType : {}) &
53 | ('getters' extends K ? GettersTransformer : {}) &
54 | ('mutations' extends K ? MutationsTransformer : {}) &
55 | ('actions' extends K ? ActionTransformer : {}) &
56 | ('modules' extends K ? ModuleTransformer : {})
57 |
58 | export const getStoreType = (
59 | store: NuxtStoreInput
60 | ) => {
61 | return {
62 | actionContext: {} as ActionContext,
63 | rootState: {} as RootStateHelper,
64 | rootGetters: {} as RootGettersHelper,
65 | storeInstance: {} as ActionContext &
66 | Exclude>, ActionContext>,
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/packages/typed-vuex/src/types/utilities.ts:
--------------------------------------------------------------------------------
1 | export type Not = T extends M ? never : T
2 |
3 | export type StoreParameter any> = Parameters<
4 | T
5 | >[1] extends undefined
6 | ? never
7 | : Parameters[1] extends NonNullable[1]>
8 | ? Parameters[1]
9 | : Parameters[1] | undefined
10 |
11 | export type MergedFunctionProcessor any, O> = Parameters<
12 | T
13 | >[1] extends undefined
14 | ? (options?: O) => ReturnType
15 | : Parameters[1] extends NonNullable[1]>
16 | ? (payload: Parameters[1], options?: O) => ReturnType
17 | : (payload?: Parameters[1], options?: O) => ReturnType
18 |
--------------------------------------------------------------------------------
/packages/typed-vuex/src/types/utils.ts:
--------------------------------------------------------------------------------
1 | export type ComputedState> = {
2 | [K in keyof T]: T[K] extends Function ? T[K] : () => T[K]
3 | }
4 |
5 | export interface Mapper> {
6 | (
7 | prop: M,
8 | properties: P[]
9 | ): ComputedState>
10 | (
11 | prop: M | M[]
12 | ): ComputedState>
13 | }
14 |
--------------------------------------------------------------------------------
/packages/typed-vuex/src/utils.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable @typescript-eslint/ban-ts-comment */
2 | import { Mapper } from './types/utils'
3 |
4 | export const createMapper = >(accessor: T) => {
5 | const mapper: Mapper = (prop: any, properties?: string[]) => {
6 | if (!properties) {
7 | return Object.fromEntries(
8 | (Array.isArray(prop) ? prop : [prop]).map(property => [
9 | property,
10 | function(...args: any[]) {
11 | const value = accessor
12 | ? accessor[property]
13 | : // @ts-ignore
14 | this.$accessor[property]
15 | if (value && typeof value === 'function') return value(...args)
16 | return value
17 | },
18 | ])
19 | )
20 | }
21 | return Object.fromEntries(
22 | properties.map(property => [
23 | property,
24 | function(...args: any[]) {
25 | const value =
26 | // @ts-ignore
27 | accessor ? accessor[prop][property] : this.$accessor[prop][property]
28 | if (value && typeof value === 'function') return value(...args)
29 | return value
30 | },
31 | ])
32 | )
33 | }
34 | return mapper
35 | }
36 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/__snapshots__/accessor.test.ts.snap:
--------------------------------------------------------------------------------
1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
2 |
3 | exports[`accessor accessor can be generated from store object 1`] = `
4 | Object {
5 | "initialiseStore": [Function],
6 | "resetEmail": [Function],
7 | "resetEmailWithOptionalPayload": [Function],
8 | "setEmail": [Function],
9 | "submodule": Object {
10 | "initialise": [Function],
11 | "nestedSubmodule": Object {
12 | "initialise": [Function],
13 | "setFirstName": [Function],
14 | "setLastName": [Function],
15 | "setName": [Function],
16 | },
17 | "setFirstName": [Function],
18 | "setLastName": [Function],
19 | "setName": [Function],
20 | },
21 | }
22 | `;
23 |
24 | exports[`accessor accessor object exists 1`] = `
25 | Object {
26 | "initialiseStore": [Function],
27 | "resetEmail": [Function],
28 | "resetEmailWithOptionalPayload": [Function],
29 | "setEmail": [Function],
30 | "submodule": Object {
31 | "initialise": [Function],
32 | "nestedSubmodule": Object {
33 | "initialise": [Function],
34 | "setFirstName": [Function],
35 | "setLastName": [Function],
36 | "setName": [Function],
37 | },
38 | "setFirstName": [Function],
39 | "setLastName": [Function],
40 | "setName": [Function],
41 | },
42 | }
43 | `;
44 |
45 | exports[`accessor accessor works with state object 1`] = `""`;
46 |
47 | exports[`accessor accessor works with state object 2`] = `"test1@email.com"`;
48 |
49 | exports[`accessor store exists 1`] = `
50 | Object {
51 | "actions": Object {
52 | "resetEmail": [Function],
53 | "resetEmailWithOptionalPayload": [Function],
54 | },
55 | "getters": Object {
56 | "email": [Function],
57 | "fullEmail": [Function],
58 | },
59 | "modules": Object {
60 | "submodule": Object {
61 | "actions": Object {
62 | "initialise": [Function],
63 | "setName": [Function],
64 | },
65 | "getters": Object {
66 | "fullName": [Function],
67 | },
68 | "modules": Object {
69 | "nestedSubmodule": Object {
70 | "actions": Object {
71 | "initialise": [Function],
72 | "setName": [Function],
73 | },
74 | "getters": Object {
75 | "fullName": [Function],
76 | },
77 | "mutations": Object {
78 | "setFirstName": [Function],
79 | "setLastName": [Function],
80 | },
81 | "namespaced": true,
82 | "state": [Function],
83 | },
84 | },
85 | "mutations": Object {
86 | "setFirstName": [Function],
87 | "setLastName": [Function],
88 | },
89 | "namespaced": true,
90 | "state": [Function],
91 | },
92 | },
93 | "mutations": Object {
94 | "initialiseStore": [Function],
95 | "setEmail": [Function],
96 | },
97 | "state": [Function],
98 | }
99 | `;
100 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/__snapshots__/utils.test.ts.snap:
--------------------------------------------------------------------------------
1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
2 |
3 | exports[`mapper works within a component with injected accessor 1`] = `
4 | "email: \\"\\"
5 | firstName: \\"\\"
6 | fullEmail: \\"\\"
7 | fullName: \\" \\""
8 | `;
9 |
10 | exports[`mapper works within a component with injected accessor 2`] = `
11 | " email: \\"daniel@test.com\\"
12 | firstName: \\"\\"
13 | fullEmail: \\"daniel@test.com\\"
14 | fullName: \\" Smith\\"
15 |
"
16 | `;
17 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/accessor.test.ts:
--------------------------------------------------------------------------------
1 | import { useAccessor, getAccessorType, getAccessorFromStore } from '../src'
2 | import Vuex, { Store } from 'vuex'
3 | import Vue from 'vue'
4 |
5 | import { getters, state, actions, mutations } from './fixture'
6 | import * as submodule from './fixture/submodule'
7 |
8 | const pattern = {
9 | getters,
10 | state,
11 | actions,
12 | mutations,
13 | modules: {
14 | submodule: {
15 | ...submodule,
16 | namespaced: true,
17 | modules: {
18 | nestedSubmodule: {
19 | ...submodule,
20 | namespaced: true,
21 | },
22 | },
23 | },
24 | },
25 | }
26 |
27 | const accessorType = getAccessorType(pattern)
28 | const submoduleAccessorType = getAccessorType(submodule)
29 |
30 | const submoduleBehaviour = (accessor: typeof submoduleAccessorType) => {
31 | expect(accessor.firstName).toEqual('')
32 | accessor.setFirstName('Nina')
33 | expect(accessor.firstName).toEqual('Nina')
34 | accessor.setLastName('Willis')
35 | expect(accessor.fullName).toEqual('Nina Willis')
36 |
37 | accessor.initialise()
38 | expect(accessor.fullName).toEqual('John Baker')
39 | accessor.setName('Jordan Lawrence')
40 | expect(accessor.lastName).toEqual('Lawrence')
41 | accessor.setName('George')
42 | expect(accessor.firstName).toEqual('George')
43 | }
44 |
45 | describe('accessor', () => {
46 | let store: Store
47 | let accessor: typeof accessorType
48 |
49 | beforeEach(() => {
50 | Vue.use(Vuex)
51 | store = new Store(pattern)
52 | accessor = useAccessor(store, pattern)
53 | })
54 | test('store exists', async () => {
55 | expect(pattern).toMatchSnapshot()
56 | })
57 | test('accessor object exists', async () => {
58 | expect(accessor).toMatchSnapshot()
59 | })
60 | test('accessor can be generated from store object', async () => {
61 | const accessorFromStore = getAccessorFromStore(store)(store)
62 | expect(accessorFromStore).toMatchSnapshot()
63 | })
64 | test('accessor works with state object', async () => {
65 | const stateAccessor = useAccessor(store, {
66 | state: {
67 | email: 'this does not matter',
68 | },
69 | mutations: {
70 | setEmail(state, newValue: string) {
71 | ;(state as any).email = newValue
72 | },
73 | },
74 | })
75 | expect(stateAccessor.email).toMatchSnapshot()
76 | stateAccessor.setEmail('test1@email.com')
77 | expect(stateAccessor.email).toMatchSnapshot()
78 | })
79 | test('accessor state, getter, mutation and actions work', async () => {
80 | expect(accessor.fullEmail).toEqual('')
81 | expect(accessor.initialiseStore()).toBeUndefined()
82 | accessor.resetEmailWithOptionalPayload('j@j.com')
83 | expect(accessor.fullEmail).toEqual('j@j.com')
84 | accessor.resetEmailWithOptionalPayload()
85 | expect(accessor.fullEmail).toEqual('a@a.com')
86 |
87 | accessor.setEmail('john@j.com')
88 | expect(accessor.email).toEqual('john@j.com')
89 | expect(accessor.fullEmail).toEqual('john@j.com')
90 |
91 | accessor.resetEmail()
92 | expect(accessor.fullEmail).toEqual('a@a.com')
93 | })
94 | test('accessor submodule state, getter, mutation and actions work', async () => {
95 | submoduleBehaviour(accessor.submodule)
96 | })
97 | test('namespaced modules work', async () => {
98 | const nonNamespacedPattern = {
99 | getters,
100 | state,
101 | actions,
102 | mutations,
103 | modules: {
104 | submodule: {
105 | ...submodule,
106 | namespaced: false,
107 | },
108 | },
109 | }
110 | const nonNamespacedStore = new Store(nonNamespacedPattern)
111 | const nonNamespacedAccessor = useAccessor(
112 | nonNamespacedStore,
113 | nonNamespacedPattern
114 | )
115 | submoduleBehaviour(nonNamespacedAccessor.submodule)
116 | })
117 | test('nested modules work', async () => {
118 | submoduleBehaviour(accessor.submodule.nestedSubmodule)
119 | })
120 | test('namespaced dynamic modules work', async () => {
121 | store.registerModule('dynamicSubmodule', { ...submodule, namespaced: true })
122 | const dynamicAccessor = useAccessor(store, {
123 | modules: { dynamicSubmodule: { ...submodule, namespaced: true } },
124 | })
125 |
126 | submoduleBehaviour(dynamicAccessor.dynamicSubmodule)
127 |
128 | store.unregisterModule('dynamicSubmodule')
129 | })
130 | test('dynamic module helper function works', async () => {
131 | store.registerModule('dynamicSubmodule', submodule)
132 | const dynamicAccessor = useAccessor(store, submodule, 'dynamicSubmodule')
133 |
134 | submoduleBehaviour(dynamicAccessor)
135 | store.unregisterModule('dynamicSubmodule')
136 | })
137 | })
138 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/fixture/index.ts:
--------------------------------------------------------------------------------
1 | import { Plugin } from 'vuex'
2 | import {
3 | getStoreType,
4 | getAccessorType,
5 | mutationTree,
6 | actionTree,
7 | } from '../../src'
8 |
9 | import * as submodule from './submodule'
10 |
11 | export const state = () => ({
12 | email: '',
13 | })
14 |
15 | type RootState = ReturnType
16 |
17 | export const getters = {
18 | email: (state: RootState) => state.email,
19 | fullEmail: (state: RootState) => state.email,
20 | }
21 |
22 | export const mutations = mutationTree(state, {
23 | setEmail(state, newValue: string) {
24 | state.email = newValue
25 | },
26 |
27 | initialiseStore() {
28 | console.log('initialised')
29 | },
30 | })
31 |
32 | export const actions = actionTree(
33 | { state, getters, mutations },
34 | {
35 | async resetEmail({ commit }) {
36 | commit('setEmail', 'a@a.com')
37 | },
38 | async resetEmailWithOptionalPayload({ commit }, optionalPayload?: string) {
39 | commit('setEmail', optionalPayload || 'a@a.com')
40 | },
41 | }
42 | )
43 |
44 | export const plugins: Plugin[] = []
45 |
46 | export const pattern = {
47 | actions,
48 | getters,
49 | mutations,
50 | state,
51 | modules: {
52 | submodule,
53 | },
54 | }
55 |
56 | export const storeType = getStoreType(pattern)
57 |
58 | export const accessorType = getAccessorType(pattern)
59 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/fixture/submodule.ts:
--------------------------------------------------------------------------------
1 | import { getterTree, mutationTree, actionTree, useAccessor } from '../../src'
2 | import { pattern } from '.'
3 |
4 | export const state = () => ({
5 | firstName: '',
6 | lastName: '',
7 | })
8 |
9 | export const getters = getterTree(state, {
10 | fullName: (state) => state.firstName + ' ' + state.lastName,
11 | })
12 |
13 | export const mutations = mutationTree(state, {
14 | setFirstName(state, newValue: string) {
15 | state.firstName = newValue
16 | },
17 | setLastName(state, newValue: string) {
18 | state.lastName = newValue
19 | },
20 | })
21 |
22 | export const actions = actionTree(
23 | { state, getters, mutations },
24 | {
25 | initialise({ commit }) {
26 | const accessor = useAccessor(this, pattern)
27 | commit('setFirstName', 'John' + accessor.email.split('@')[0])
28 | commit('setLastName', 'Baker')
29 | },
30 | setName({ commit }, newName: string) {
31 | const names = newName.split(' ')
32 | commit('setFirstName', names[0])
33 | if (names.length > 1) commit('setLastName', names[1])
34 | },
35 | }
36 | )
37 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/tsd/accessor.test-d.ts:
--------------------------------------------------------------------------------
1 | import { DispatchOptions, CommitOptions } from 'vuex'
2 | import { expectType, expectError } from 'tsd'
3 |
4 | import { getAccessorType } from '../..'
5 | import { getters, state, actions, mutations } from '../fixture'
6 |
7 | import * as submodule from '../fixture/submodule'
8 |
9 | const pattern = {
10 | getters,
11 | state,
12 | actions,
13 | mutations,
14 | modules: {
15 | submodule: {
16 | ...submodule,
17 | namespaced: true,
18 | modules: {
19 | nestedSubmodule: {
20 | ...submodule,
21 | namespaced: true,
22 | },
23 | },
24 | },
25 | },
26 | }
27 |
28 | const accessorType = getAccessorType(pattern)
29 | const submoduleAccessorType = getAccessorType(submodule)
30 |
31 | expectType(accessorType.fullEmail)
32 | expectType(accessorType.submodule.fullName)
33 | expectType(accessorType.submodule.lastName)
34 | interface CommitFunction {
35 | (payload: string, options?: CommitOptions): void
36 | }
37 | expectType(accessorType.setEmail)
38 |
39 | interface ActionFunction {
40 | (options?: DispatchOptions): Promise
41 | }
42 | interface ActionFunctionWithOptionalPayload {
43 | (payload?: string | undefined, options?: DispatchOptions): Promise
44 | }
45 | expectType(accessorType.resetEmail)
46 | expectType(
47 | accessorType.resetEmailWithOptionalPayload
48 | )
49 |
50 | expectType(submoduleAccessorType.firstName)
51 | expectType(submoduleAccessorType.initialise())
52 | expectError(submoduleAccessorType.initialise('argument'))
53 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/tsd/map-state.test-d.ts:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 | import { getAccessorType, createMapper } from '../..'
3 | import { expectType } from 'tsd'
4 |
5 | import { getters, state, actions, mutations } from '../fixture'
6 |
7 | import * as submodule from '../fixture/submodule'
8 | import { CommitOptions, DispatchOptions } from 'vuex/types/index'
9 |
10 | const pattern = {
11 | getters,
12 | state,
13 | actions,
14 | mutations,
15 | modules: {
16 | submodule: {
17 | ...submodule,
18 | namespaced: true,
19 | modules: {
20 | nestedSubmodule: {
21 | ...submodule,
22 | namespaced: true,
23 | },
24 | },
25 | },
26 | },
27 | }
28 |
29 | const accessor = getAccessorType(pattern)
30 | const mapper = createMapper(accessor)
31 |
32 | Vue.extend({
33 | computed: {
34 | ...mapper(['email']),
35 | ...mapper('fullEmail'),
36 | ...mapper('submodule', ['fullName']),
37 | },
38 | methods: {
39 | ...mapper('submodule', ['setFirstName', 'setName']),
40 | ...mapper(['resetEmail', 'initialiseStore']),
41 | test(): void {
42 | // actions
43 | expectType<(options?: DispatchOptions | undefined) => Promise>(
44 | this.resetEmail
45 | )
46 | expectType<
47 | (payload: string, options?: DispatchOptions | undefined) => void
48 | >(this.setName)
49 | // getter
50 | expectType(this.fullEmail)
51 | expectType(this.fullName)
52 | // state
53 | expectType(this.email)
54 | // mutations
55 | expectType<
56 | (payload: string, options?: CommitOptions | undefined) => void
57 | >(this.setFirstName)
58 | expectType<(options?: CommitOptions | undefined) => void>(
59 | this.initialiseStore
60 | )
61 | },
62 | },
63 | })
64 |
--------------------------------------------------------------------------------
/packages/typed-vuex/test/utils.test.ts:
--------------------------------------------------------------------------------
1 | /** @jest-environment jsdom */
2 |
3 | import { useAccessor, getAccessorType, createMapper, Mapper } from '../src'
4 | import { mount, createLocalVue } from '@vue/test-utils'
5 | import Vuex, { Store } from 'vuex'
6 |
7 | import { getters, state, actions, mutations } from './fixture'
8 | import * as submodule from './fixture/submodule'
9 |
10 | const pattern = {
11 | getters,
12 | state,
13 | actions,
14 | mutations,
15 | modules: {
16 | submodule: {
17 | ...submodule,
18 | namespaced: true,
19 | modules: {
20 | nestedSubmodule: {
21 | ...submodule,
22 | namespaced: true,
23 | },
24 | },
25 | },
26 | },
27 | }
28 |
29 | const accessorType = getAccessorType(pattern)
30 |
31 | describe('mapper', () => {
32 | let store: Store
33 | let accessor: typeof accessorType
34 | let mapper: Mapper
35 | let Vue
36 | // let nuxtMapper: Mapper
37 |
38 | beforeEach(() => {
39 | Vue = createLocalVue()
40 | Vue.use(Vuex)
41 | store = new Store(pattern)
42 | accessor = useAccessor(store, pattern)
43 | mapper = createMapper(accessor)
44 | })
45 |
46 | test('mapper works with state', () => {
47 | expect(mapper('email').email()).toEqual('')
48 | expect(mapper('submodule', ['firstName']).firstName()).toEqual('')
49 | })
50 | test('mapper works with getters', () => {
51 | expect(mapper('fullEmail').fullEmail()).toEqual('')
52 | expect(mapper('submodule', ['fullName']).fullName()).toEqual(' ')
53 | })
54 | test('mapper works with mutations', () => {
55 | mapper('setEmail').setEmail('example@email.com')
56 | expect(accessor.email).toEqual('example@email.com')
57 | mapper('submodule', ['setLastName']).setLastName('Smith')
58 | expect(accessor.submodule.fullName).toEqual(' Smith')
59 | })
60 | test('mapper works with actions', () => {
61 | mapper('resetEmail').resetEmail()
62 | expect(accessor.email).toEqual('a@a.com')
63 | })
64 | test('works within a component with injected accessor', async () => {
65 | const mapper = createMapper(accessorType)
66 | Vue.prototype.$accessor = accessor
67 | const Component = {
68 | template: `
69 | email: {{ JSON.stringify(email) }}
70 | firstName: {{ JSON.stringify(firstName) }}
71 | fullEmail: {{ JSON.stringify(fullEmail) }}
72 | fullName: {{ JSON.stringify(fullName) }}
73 | `,
74 | computed: {
75 | ...mapper('email'),
76 | ...mapper('submodule', ['firstName']),
77 | ...mapper('fullEmail'),
78 | ...mapper('submodule', ['fullName']),
79 | },
80 | methods: {
81 | ...mapper(['setEmail', 'resetEmail']),
82 | ...mapper('submodule', ['setLastName']),
83 | },
84 | }
85 | const wrapper = mount(Component, {
86 | store,
87 | localVue: Vue,
88 | })
89 | expect(wrapper.text()).toMatchSnapshot()
90 | wrapper.vm.setEmail('daniel@test.com')
91 | wrapper.vm.setLastName('Smith')
92 | await Vue.nextTick()
93 |
94 | expect(wrapper.html()).toMatchSnapshot()
95 | })
96 | })
97 |
--------------------------------------------------------------------------------
/packages/typed-vuex/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "../../tsconfig.json",
3 | "compilerOptions": {
4 | "rootDir": "src",
5 | "outDir": "lib",
6 | "lib": ["esnext", "dom"]
7 | },
8 | "exclude": ["node_modules", "lib", "test"]
9 | }
10 |
--------------------------------------------------------------------------------
/pnpm-workspace.yaml:
--------------------------------------------------------------------------------
1 | packages:
2 | - "packages/**"
3 | - "docs"
4 |
--------------------------------------------------------------------------------
/prettier.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | semi: false,
3 | singleQuote: true,
4 | trailingComma: 'es5',
5 | }
6 |
--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": [
3 | "github>danielroe/renovate"
4 | ],
5 | "ignoreDeps": [
6 | "docus",
7 | "vue",
8 | "vuex"
9 | ],
10 | "$schema": "https://docs.renovatebot.com/renovate-schema.json"
11 | }
12 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "strict": true,
4 | "sourceMap": true,
5 | "resolveJsonModule": true,
6 | "declaration": true,
7 | "target": "esnext",
8 | "module": "esnext",
9 | "moduleResolution": "node",
10 | "esModuleInterop": true,
11 | "lib": ["esnext", "dom"]
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/vercel.json:
--------------------------------------------------------------------------------
1 | {
2 | "builds": [
3 | {
4 | "src": "docs/package.json",
5 | "use": "@vercel/static-build"
6 | }
7 | ],
8 | "routes": [{ "handle": "filesystem" }, { "src": "/(.*)", "dest": "/docs/$1" }]
9 | }
10 |
--------------------------------------------------------------------------------
7 |
8 |
9 | 
10 |
11 |
12 | 
13 |
14 | 
18 |
19 |
20 | 
27 |
28 |