vuex-composition-helpers - GitLite

KO | EN

gitlite — search

#javascript #python #ai #typescript #llm #deep-learning #docker #windows #vue #awesome-list #pytorch #security #ios #openai

vuex-composition-helpers

(★ 288)

A util package to use Vuex with Composition API easily.

File Explorer

Download Latest Version (.zip)

- - release.yml
  - test.yml
- global.ts
- index.ts
- namespaced.ts
- util.ts
- wrapper.ts
- - local-vue.ts
- global-actions.test.ts
- global-getters.test.ts
- global-mutations.test.ts
- global-state.test.ts
- namespaced-actions.test.ts
- namespaced-getters.test.ts
- namespaced-helpers.test.ts
- namespaced-mutations.test.ts
- namespaced-state.test.ts
.gitignore
.npmignore
jest.config.js
LICENSE
package-lock.json
package.json
README.md
tsconfig.json
tsconfig.test.json

# Installation Guide

1. Get the code

git clone https://github.com/greenpress/vuex-composition-helpers

Downloads the entire project code from GitHub to your computer.

cd vuex-composition-helpers

Moves into the project folder you just downloaded.

2. Node.js

Easy Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Node.js Node.js must be installed to use npm. The LTS version is recommended.

$ npm install vuex-composition-helpers

Downloads and installs the libraries listed in package.json.

$ yarn add vuex-composition-helpers

Type this command into your terminal and run it.

$ pnpm install vuex-composition-helpers

Downloads and installs the libraries listed in package.json.

$ npm install vuex-composition-helpers@1.2.0

Downloads and installs the libraries listed in package.json.

$ yarn add vuex-composition-helpers@1.2.0

Type this command into your terminal and run it.

✅ After running the command, open the address shown in the terminal (usually something like http://localhost:3000) in your browser.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# vuex-composition-helpers

![CI](https://github.com/greenpress/vuex-composition-helpers/workflows/CI/badge.svg?branch=master)
[![npm version](https://badge.fury.io/js/vuex-composition-helpers.svg)](https://badge.fury.io/js/vuex-composition-helpers)

A util package to use Vuex with Composition API easily.

## Installation

### For Vue 2.0-2.6.x - 1.1.x
```shell
$ npm install vuex-composition-helpers

$ yarn add vuex-composition-helpers

$ pnpm install vuex-composition-helpers
```

### For Vue ^2.7 - 1.2.x
```shell
$ npm install vuex-composition-helpers@1.2.0

$ yarn add vuex-composition-helpers@1.2.0

$ pnpm install vuex-composition-helpers@1.2.0
```

### For Vue 3.x - use the `next` tag:
```shell
$ npm install vuex-composition-helpers@next

$ yarn add vuex-composition-helpers@next

$ pnpm install vuex-composition-helpers@next
```

This library is not transpiled by default. Your project should transpile it, which makes the final build smaller and more tree-shakeable. Take a look at [transpiling](#transpiling).

Non-typescript projects may import the library from the `dist` subdirectory, where plain javascript distribution files are located.

```
import { useState, ... } from 'vuex-composition-helpers/dist';
```

### Basic Usage Examples

```js
import { useState, useActions } from 'vuex-composition-helpers';

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { fetch } = useActions(['fetch']);
		const { article, comments } = useState(['article', 'comments']);
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

### Namespaced Usage Examples

#### `createNamespacedHelpers`
```js
import { createNamespacedHelpers } from 'vuex-composition-helpers';
const { useState, useActions } = createNamespacedHelpers('articles'); // specific module name

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { fetch } = useActions(['fetch']);
		const { article, comments } = useState(['article', 'comments']);
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

You can also import your store from outside the component, and create the helpers outside of the `setup` method, for example:

```js
import { createNamespacedHelpers } from 'vuex-composition-helpers';
import store from '../store'; // local store file
import const { useState, useActions } = createNamespacedHelpers(store, 'articles'); // specific module name
const { fetch } = useActions(['fetch']);

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { article, comments } = useState(['article', 'comments']);
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

#### Inline namespacing
```js
import { useState, useActions } from 'vuex-composition-helpers';

export default {
	setup(props) {
		const { article, comments } = useState('sections/blog', ['article', 'comments']);
		return { article, comments }
	}
}
```

### Typescript mappings

You can also supply typing information to each of the mapping functions to provide a fully typed mapping.

```ts
import { useState, useActions } from 'vuex-composition-helpers';

interface RootGetters extends GetterTree<any, any> {
	article: string;
	comments: string;
}

interface RootActions extends ActionTree<any, any> {
	fetch: (ctx: ActionContext<any, any>, payload: number);
}

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { fetch } = useActions<RootActions>(['fetch']);
		const { article, comments } = useGetters<RootGetters>(['article', 'comments']);
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

#### Typescript Namespaced Usage Example

```ts
import { useState, useActions } from 'vuex-composition-helpers';
import { ModuleState, ModuleGetters, ModuleActions, ModuleMutations } from "../store/subModule"

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { useState, useActions } = createNamespacedHelpers<
			ModuleState,
			ModuleGetters,
			ModuleActions,
			ModuleMutations
		>('articles'); // specific module name and generics
		const { fetch } = useActions(['fetch']); // no generics needed any more
		const { article, comments } = useGetters(['article', 'comments']); // no generics needed any more
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

### Advanced Usage Example

Consider separate the store composition file from the store usage inside the component. i.g.:

```js
// store-composition.js:
import { wrapStore } from 'vuex-composition-helpers';
import store from '@/store'; // local store file

export default wrapStore(store);
```

```js
// my-component.vue:
import { createNamespacedHelpers } from './store-composition.js';
const { useState, useActions } = createNamespacedHelpers('articles'); // specific module name
const { fetch } = useActions(['fetch']);

export default {
	props: {
		articleId: String
	},
	setup(props) {
		const { article, comments } = useState(['article', 'comments']);
		fetch(props.articleId); // dispatch the "fetch" action

return {
			// both are computed compositions for to the store
			article,
			comments
		}
	}
}
```

### Transpiling

It depends on you project's stack, but let's say it consists of webpack, babel and ts-loader.

The rule processing `.ts` files should whitelist vuex-composition-helpers. If your project uses a raw webpack installation, it should resemble this.

```js
// webpack.config.js
module.exports = {
  ...
  module: {
    rules: [
      test: /\.ts$/,
      // If node_modules is excluded from the rule, vuex-composition-helpers should be an exception
      exclude: /node_modules(?!\/vuex-composition-helpers)/,
      use: [
        {
          loader: 'babel-loader',
          ...
        },
        {
          loader: 'thread-loader',
          options: { ... }
        },
        {
          loader: 'ts-loader',
          ...
        }
    ]
  }
}
```

When using `vue-cli`, use this instead

```js
// vue.config.js
module.exports = {
  ...
  chainWebpack: config => {
    config
      .rule('ts')
      .include
      .add(/vuex-composition-helpers/)
  }
}
```

If your webpack configuration is excluding `node_modules` from the bundle, which is common for SSR, this library should be an exception.

```
// webpack.config.js
module.exports = {
 ...
  externals: [nodeExternals({
    whitelist: [/^vuex-composition-helpers/]
  })],
}
```

Babel should not `exclude` or `ignore` this library. If you use `vue-cli`, you may need the following configuration.

```js
// vue.config.js
module.exports = {
  ...
  transpileDependencies: ['vuex-composition-helpers'],
}
```

Although it's not strictly required, maybe ts-loader needs to have `allowTsInNodeModules` enabled in your project. Finally check that this library is not excluded in `tsconfig.json`, and if it was necessary, put it in the `include` list.

Enjoy!